//! First-party lifecycle hook providers.//!//! The Herdr provider reports semantic foreground state for interactive work.//! Notification hooks live in `notifications` and keep sound policy outside//! the Core hook harness. const std = @import("std");const hooks = @import("../core/hooks/hooks.zig");const herdr = @import("hooks/herdr.zig"); pub const notifications = @import("hooks/notifications.zig");pub const Client = herdr.Client; pub fn Runtime(comptime App: type) type {    return struct {        /// Must run before the lifecycle runtime is frozen (currently the        /// notification runtime performs the sole freeze right after this).        pub fn configure(app: *App, active_session_id: ?[]const u8) !void {            app.herdr.initFromEnv(app.alloc);            if (!app.herdr.enabled) return;             if (active_session_id) |session_id| {                app.herdr.reportSession(session_id);            }            app.herdr.reportState(.idle, null);            app.herdr.announce();             try register(app);        }         fn register(app: *App) !void {            try app.lifecycle_runtime.registerPostTurnEnd(.{                .name = "fx.herdr.turn_end",                .ctx = app,                .run = postTurnEndHandler,            });            try app.lifecycle_runtime.registerAttentionRequired(.{                .name = "fx.herdr.attention_required",                .ctx = app,                .run = attentionRequiredHandler,            });        }         pub fn reportWorking(app: *App) void {            app.herdr.reportState(.working, null);        }         fn postTurnEndHandler(            raw: *anyopaque,            input: hooks.PostTurnEndInput,        ) hooks.HandlerError!void {            const app: *App = @ptrCast(@alignCast(raw));            if (input.invocation.scope.kind != .interactive) return;            app.herdr.reportState(.idle, null);        }         fn attentionRequiredHandler(            raw: *anyopaque,            input: hooks.AttentionRequiredInput,        ) hooks.HandlerError!void {            const app: *App = @ptrCast(@alignCast(raw));            if (input.invocation.scope.kind != .interactive) return;            app.herdr.reportState(.blocked, attentionStatus(input.kind));        }         fn attentionStatus(kind: hooks.AttentionKind) []const u8 {            return switch (kind) {                .permission => "permission",                .question => "question",                .route_recovery => "recovery",            };        }    };} const RecordingClient = struct {    const Report = struct {        state: herdr.State,        status: ?[]const u8,    };     reports: [6]Report = undefined,    report_count: usize = 0,    enabled: bool = false,    enable_on_init: bool = true,    initialized: bool = false,    announced: bool = false,    session_id: ?[]const u8 = null,     fn initFromEnv(self: *RecordingClient, _: std.mem.Allocator) void {        self.initialized = true;        self.enabled = self.enable_on_init;    }     fn reportSession(self: *RecordingClient, session_id: []const u8) void {        self.session_id = session_id;    }     fn announce(self: *RecordingClient) void {        self.announced = true;    }     fn reportState(self: *RecordingClient, state: herdr.State, status: ?[]const u8) void {        self.reports[self.report_count] = .{ .state = state, .status = status };        self.report_count += 1;    }}; test "built-in Herdr hooks report only interactive lifecycle state" {    const TestApp = struct {        alloc: std.mem.Allocator,        lifecycle_runtime: hooks.Runtime,        herdr: RecordingClient = .{},    };    const Provider = Runtime(TestApp);     var app = TestApp{        .alloc = std.testing.allocator,        .lifecycle_runtime = hooks.Runtime.init(std.testing.allocator),    };    defer app.lifecycle_runtime.deinit();     try Provider.configure(&app, "session-42");    const view = app.lifecycle_runtime.freeze();    try std.testing.expect(app.herdr.initialized);    try std.testing.expect(app.herdr.announced);    try std.testing.expectEqualStrings("session-42", app.herdr.session_id orelse return error.TestExpectedEqual);    try std.testing.expect(view.hasPostTurnEnd());    try std.testing.expect(view.hasAttentionRequired());     Provider.reportWorking(&app);    view.runPostTurnEnd(.{        .invocation = testInvocation(.ask),        .outcome = .completed,    });    view.runPostTurnEnd(.{        .invocation = testInvocation(.interactive),        .outcome = .completed,    });    view.runAttentionRequired(.{        .invocation = testInvocation(.acp),        .kind = .permission,    });    view.runAttentionRequired(.{        .invocation = testInvocation(.interactive),        .kind = .permission,    });    view.runAttentionRequired(.{        .invocation = testInvocation(.interactive),        .kind = .question,    });    view.runAttentionRequired(.{        .invocation = testInvocation(.interactive),        .kind = .route_recovery,    });     try std.testing.expectEqual(@as(usize, 6), app.herdr.report_count);    try expectReport(app.herdr.reports[0], .idle, null);    try expectReport(app.herdr.reports[1], .working, null);    try expectReport(app.herdr.reports[2], .idle, null);    try expectReport(app.herdr.reports[3], .blocked, "permission");    try expectReport(app.herdr.reports[4], .blocked, "question");    try expectReport(app.herdr.reports[5], .blocked, "recovery");} test "disabled built-in Herdr provider registers no lifecycle hooks" {    const TestApp = struct {        alloc: std.mem.Allocator,        lifecycle_runtime: hooks.Runtime,        herdr: RecordingClient = .{ .enable_on_init = false },    };     var app = TestApp{        .alloc = std.testing.allocator,        .lifecycle_runtime = hooks.Runtime.init(std.testing.allocator),    };    defer app.lifecycle_runtime.deinit();     try Runtime(TestApp).configure(&app, "session-42");    const view = app.lifecycle_runtime.freeze();    try std.testing.expect(app.herdr.initialized);    try std.testing.expect(!app.herdr.announced);    try std.testing.expect(app.herdr.session_id == null);    try std.testing.expectEqual(@as(usize, 0), app.herdr.report_count);    try std.testing.expect(!view.hasPostTurnEnd());    try std.testing.expect(!view.hasAttentionRequired());} fn testInvocation(kind: hooks.ScopeKind) hooks.Invocation {    return .{        .scope = .{            .kind = kind,            .workspace_root = "/tmp/workspace",            .session_id = "session",        },        .turn_id = 42,    };} fn expectReport(actual: RecordingClient.Report, state: herdr.State, status: ?[]const u8) !void {    try std.testing.expectEqual(state, actual.state);    if (status) |expected| {        try std.testing.expectEqualStrings(expected, actual.status orelse return error.TestExpectedEqual);    } else {        try std.testing.expect(actual.status == null);    }}