const std = @import("std");const permission_request = @import("../../core/permissions/permission_request.zig");const types = @import("../../core/shared/types.zig");const manager_mod = @import("../../core/subagent/manager.zig");const projection = @import("../../core/subagent/ui_projection.zig");const terminal_projection = @import("../../core/terminal/ui_projection.zig");const execution = @import("../../core/subagent/execution.zig");const domain = @import("../../core/subagent/domain.zig");const input_action = @import("../../core/input/input_action.zig");const core_input_runtime = @import("../../core/input/runtime.zig");const transcript_presentation = @import("../../core/output/transcript_presentation.zig");const skill_contract = @import("../../core/skills/skill_contract.zig");const subagent_runtime = @import("runtime.zig");const render_request = @import("../render_request.zig");const transcript_runtime = @import("../transcript/runtime.zig"); const Allocator = std.mem.Allocator; pub const KeyAction = subagent_runtime.Command;pub const InputAction = subagent_runtime.Action;pub const ToggleResult = enum { changed };pub const ChildPresentationView = subagent_runtime.ChildPresentationView; pub const Controller = struct {    runtime: subagent_runtime.Runtime = .{},    view_active: bool = false,    last_refresh_ms: i64 = 0,     pub fn deinit(self: *Controller, alloc: Allocator) void {        self.runtime.deinit(alloc);        self.view_active = false;    }     pub fn isViewActive(self: Controller) bool {        return self.view_active;    }     pub fn open(self: *Controller, alloc: Allocator) void {        self.runtime.resetForOpen(alloc);        self.view_active = true;    }     pub fn close(self: *Controller, alloc: Allocator) void {        self.runtime.resetForOpen(alloc);        self.view_active = false;    }     pub fn clearProjection(self: *Controller, alloc: Allocator) void {        self.runtime.clearProjection(alloc);        self.last_refresh_ms = 0;    }     pub fn count(self: Controller) usize {        return self.runtime.count();    }     pub fn setCountProjection(self: *Controller, projected_count: usize) void {        self.runtime.setCountProjection(projected_count);    }     pub fn hasEntries(self: Controller) bool {        return self.count() > 0 or self.runtime.selectedTerminalId() != null;    }     pub fn snapshotEntries(self: Controller, alloc: Allocator) ![]subagent_runtime.EntryView {        return self.runtime.snapshotEntries(alloc);    }     pub fn selectedInfo(self: Controller) ?subagent_runtime.SelectedInfo {        return self.runtime.selectedInfo();    }     pub fn replaceSnapshot(self: *Controller, alloc: Allocator, snapshot: projection.Snapshot) !bool {        return self.runtime.replaceSnapshot(alloc, snapshot);    }     pub fn replaceTerminalSnapshot(        self: *Controller,        alloc: Allocator,        snapshot: terminal_projection.Snapshot,    ) !bool {        return self.runtime.replaceTerminalSnapshot(alloc, snapshot);    }     pub fn selectedTerminalId(self: *const Controller) ?[]const u8 {        return self.runtime.selectedTerminalId();    }     pub fn pageCursor(self: Controller) ?[]const u8 {        return self.runtime.pageCursor();    }     pub fn pendingApprovalOffset(self: Controller) usize {        return self.runtime.pendingApprovalOffset();    }     pub fn pageAnchorId(self: Controller) ?[]const u8 {        return self.runtime.pageAnchorId();    }     pub fn refreshDue(self: *Controller, now_ms: i64, force: bool) bool {        const interval_ms: i64 = if (self.view_active) 100 else 250;        if (!force and now_ms - self.last_refresh_ms < interval_ms) return false;        self.last_refresh_ms = now_ms;        return true;    }     pub fn projectionRefreshDue(        self: *Controller,        now_ms: i64,        force: bool,        pending_approval_revision: u64,    ) bool {        if (self.view_active) return self.refreshDue(now_ms, force);        if (!force and            self.runtime.approvalRevision() == pending_approval_revision) return false;        self.last_refresh_ms = now_ms;        return true;    }     pub fn mainApprovalRequest(self: *const Controller) ?permission_request.PermissionRequest {        return self.runtime.mainApprovalRequest();    }     pub fn markMainApprovalPresented(self: *Controller, presented: bool) void {        self.runtime.markMainApprovalPresented(presented);    }     pub fn mainApprovalPresented(self: Controller) bool {        return self.runtime.mainApprovalPresented();    }     pub fn mainApprovalBinding(        self: *const Controller,        prompt_id: u64,    ) ?subagent_runtime.MainApprovalBinding {        return self.runtime.mainApprovalBinding(prompt_id);    }     pub fn dismissMainApproval(self: *Controller) void {        self.runtime.dismissMainApproval();    }     pub fn setDegraded(self: *Controller, alloc: Allocator, failure: manager_mod.FailureCode) void {        self.runtime.setDegraded(alloc, failure);    }     pub fn setDefaults(        self: *Controller,        alloc: Allocator,        model: []const u8,        effort: types.ReasoningEffort,    ) !void {        try self.runtime.setDefaults(alloc, model, effort);    }     pub fn handleAction(self: *Controller, alloc: Allocator, action: InputAction) !KeyAction {        return self.handleActionWithMainApproval(alloc, action, null);    }     pub fn handleActionWithMainApproval(        self: *Controller,        alloc: Allocator,        action: InputAction,        main_approval_id: ?u64,    ) !KeyAction {        return self.runtime.handleWithMainApproval(alloc, action, main_approval_id);    }     pub const Acknowledgement = struct {        child_id: []const u8,        through_sequence: u64,    };     pub fn acknowledgement(self: *const Controller) ?Acknowledgement {        if (self.runtime.pendingChildAcknowledgement()) |pending| {            return .{                .child_id = pending.child_id,                .through_sequence = pending.through_sequence,            };        }        const node = self.runtime.routedNode() orelse return null;        if (node.through_sequence == 0) return null;        return .{ .child_id = node.child_id, .through_sequence = node.through_sequence };    }     pub fn acknowledgementAttempted(        self: *Controller,        alloc: Allocator,        attempted: Acknowledgement,    ) void {        self.runtime.childAcknowledgementAttempted(            alloc,            attempted.child_id,            attempted.through_sequence,        );    }     pub fn visibleChildAcknowledgement(self: *const Controller) ?Acknowledgement {        const through_sequence = self.runtime.visibleChildAcknowledgementSequence() orelse return null;        const child_id = self.runtime.childRouteId() orelse return null;        return .{ .child_id = child_id, .through_sequence = through_sequence };    }     pub fn handleKey(self: *Controller, alloc: Allocator, byte: u8) !KeyAction {        return self.handleKeyWithMainApproval(alloc, byte, null);    }     pub fn handleKeyWithMainApproval(        self: *Controller,        alloc: Allocator,        byte: u8,        main_approval_id: ?u64,    ) !KeyAction {        return self.runtime.handleByte(alloc, byte, main_approval_id);    }     pub fn childRouteId(self: *const Controller) ?[]const u8 {        return self.runtime.childRouteId();    }     pub fn childPresentationView(        self: *const Controller,    ) ?ChildPresentationView {        return self.runtime.childPresentationView();    }     pub fn childComposerFocused(self: *const Controller) bool {        return self.runtime.childComposerFocused();    }     pub fn childComposerEditor(self: *Controller) ?*core_input_runtime.Runtime {        return self.runtime.childComposerEditor();    }     pub fn moveChildInputCursor(        self: *Controller,        intent: input_action.MoveIntent,        terminal_cols: u16,        page_rows: usize,    ) bool {        return self.runtime.moveChildInputCursor(intent, terminal_cols, page_rows);    }     pub fn commitChildEditorEdit(self: *Controller, alloc: Allocator) void {        self.runtime.commitChildEditorEdit(alloc);    }     pub fn clearChildComposer(self: *Controller, alloc: Allocator) void {        self.runtime.clearChildComposer(alloc);    }     pub fn bindSelectedChildSkill(        self: *Controller,        alloc: Allocator,        name: []const u8,        path: []const u8,        display_source: ?skill_contract.SkillSource,    ) !bool {        return self.runtime.bindSelectedChildSkill(            alloc,            name,            path,            display_source,        );    }     pub fn invalidateChildConversationProjection(        self: *Controller,        alloc: Allocator,    ) void {        self.runtime.invalidateChildConversationProjection(alloc);    }     pub fn openSelectedChildModelConfiguration(        self: *Controller,        alloc: Allocator,        model: []const u8,    ) !KeyAction {        return self.runtime.openSelectedChildModelConfiguration(alloc, model);    }     pub fn commitChildPresentationViewport(        self: *Controller,        total_rows: u32,        max_rows_from_bottom: u32,        rows_from_bottom: u32,    ) void {        self.runtime.commitChildPresentationViewport(            total_rows,            max_rows_from_bottom,            rows_from_bottom,        );    }     pub fn managerPasteActive(self: *const Controller) bool {        return self.view_active and self.runtime.managerPasteActive();    }     pub fn beginManagerPaste(self: *Controller) void {        if (!self.view_active) return;        self.runtime.beginManagerPaste();    }     pub fn consumeManagerPasteByte(        self: *Controller,        alloc: Allocator,        byte: u8,    ) !bool {        if (!self.view_active) return false;        return self.runtime.consumeManagerPasteByte(alloc, byte);    }     pub fn settleManagerPasteDeliveryEpoch(        self: *Controller,        alloc: Allocator,    ) bool {        if (!self.view_active) return false;        return self.runtime.settleManagerPasteDeliveryEpoch(alloc);    }     pub fn childPasteActive(self: Controller) bool {        return self.runtime.childPasteActive();    }     pub fn beginChildPaste(self: *Controller) void {        self.runtime.beginChildPaste();    }     pub fn consumeChildPasteByte(        self: *Controller,        alloc: Allocator,        byte: u8,    ) !bool {        return self.runtime.consumeChildPasteByte(alloc, byte);    }     pub fn installChildChat(        self: *Controller,        alloc: Allocator,        chat: projection.ChildChat,        older_page: bool,        reset_pages: bool,    ) !void {        try self.runtime.installChildChat(            alloc,            chat,            older_page,            reset_pages,        );    }     pub fn replaceChildLive(        self: *Controller,        alloc: Allocator,        live: ?execution.LivePresentation,    ) bool {        return self.runtime.replaceChildLive(alloc, live);    }     pub fn childConversationRuntime(        self: *Controller,    ) ?*transcript_runtime.TranscriptRuntime {        return self.runtime.childConversationRuntime();    }     pub fn childFullTranscriptRequested(self: Controller) bool {        return self.view_active and            self.runtime.childFullTranscriptRequested();    }     pub fn childTranscriptPresentationDepth(        self: Controller,    ) transcript_presentation.Depth {        if (!self.view_active) return .inline_mode;        return self.runtime.childTranscriptPresentationDepth();    }     pub fn setChildTranscriptPresentationDepth(        self: *Controller,        alloc: Allocator,        requested: transcript_presentation.Depth,    ) !transcript_presentation.Depth {        if (!self.view_active) return .inline_mode;        return self.runtime.setChildTranscriptPresentationDepth(            alloc,            requested,        );    }     pub fn closeChildTranscriptPresentation(        self: *Controller,        alloc: Allocator,    ) !bool {        if (!self.view_active) return false;        return self.runtime.closeChildTranscriptPresentation(alloc);    }     pub fn activeRenderRequests(        self: *Controller,    ) *render_request.RenderRequestState {        return self.runtime.activeRenderRequests();    }     pub fn activateManagerSurface(self: *Controller) void {        self.runtime.activateManagerSurface();    }     pub fn activateChildConversationSurface(self: *Controller) bool {        return self.runtime.activateChildConversationSurface();    }     pub fn activateChildCatalogSurface(self: *Controller) bool {        return self.runtime.activateChildCatalogSurface();    }     pub fn installChildConversationRuntime(        self: *Controller,        alloc: Allocator,        runtime_value: transcript_runtime.TranscriptRuntime,        diff_entries: std.ArrayList(            @import("../../core/output/diff.zig").DiffEntry,        ),        live: ?execution.LivePresentation,        next_diff_id: u32,    ) !void {        try self.runtime.installChildConversationRuntime(            alloc,            runtime_value,            diff_entries,            live,            next_diff_id,        );    }     pub fn markChildConversationEventsAppliedThrough(        self: *Controller,        live: execution.LivePresentation,        event_count: usize,        next_diff_id: u32,    ) void {        self.runtime.markChildConversationEventsAppliedThrough(            live,            event_count,            next_diff_id,        );    }     pub fn childConversationEventCount(self: Controller) usize {        return self.runtime.childConversationEventCount();    }     pub fn childConversationNextDiffId(self: Controller) u32 {        return self.runtime.childConversationNextDiffId();    }     pub fn childConversationDiffEntries(        self: *Controller,    ) *std.ArrayList(@import("../../core/output/diff.zig").DiffEntry) {        return self.runtime.childConversationDiffEntries();    }     pub fn childFullTranscriptDiffResolver(        self: *Controller,    ) ?@import("../full_transcript_screen.zig").FullDiffResolver {        return self.runtime.childFullTranscriptDiffResolver();    }     pub fn setChildUnavailable(        self: *Controller,        alloc: Allocator,        unavailable: projection.ChildUnavailable,    ) void {        self.runtime.setChildUnavailable(alloc, unavailable);    }     pub fn olderHistoryCursor(self: Controller) ?[]const u8 {        return self.runtime.olderHistoryCursor();    }     pub fn prepareSubmission(        self: *Controller,        alloc: Allocator,        timestamp_ms: i64,    ) !?subagent_runtime.Runtime.Submission {        return self.runtime.prepareSubmission(alloc, timestamp_ms);    }     pub fn assignSubmissionIdentity(        self: *Controller,        invocation_id: []const u8,        identity_epoch: u64,    ) bool {        return self.runtime.assignSubmissionIdentity(invocation_id, identity_epoch);    }     pub fn submissionAccepted(self: *Controller, alloc: Allocator) void {        self.runtime.submissionAccepted(alloc);    } 

Lines 1–500 of 646. Load more