sortie-dogs 0.11.0 → 0.11.2

package/README.md

@@ -51,6 +51,12 @@ The auxiliary settings select Luna6 Fast for summaries and titles. Keep any
 additional settings on those agents. Sortie permits SOL6 and Luna6 for its
 execution requests; reviewer/advisor model selections are independent.
 
+The package exposes a native `./tui` entry for the live work overview. If you use
+a local V2 wrapper, place `export { default } from "sortie-dogs/server";` in
+`.opencode/plugins/sortie-dogs/index.js` and register that directory. `init` installs
+its companion `tui.tsx` alongside it. For a global installation, use the same
+`plugins/sortie-dogs/` layout under the OpenCode global config directory.
+
 Restart the OpenCode host after installing or updating the plugin, then run:
 
 ```text
@@ -91,6 +97,22 @@ execution plan, exact-file manifest, or model-authored proof mapping.
 Technical scope and useful verification commands are discovered while working.
 Project `AGENTS.md`, user instructions and native OpenCode permissions remain authoritative.
 
+### Execution progress and bounded discovery
+
+The native child call publishes host-observed progress every five seconds: elapsed
+time, current inspection/command, last exit, command starts and edits. The same
+information is available through `sortie_v011_work_status`. Activity is never
+treated as completed work or an inferred benchmark score. Long jobs should reuse
+their existing controller and ledger, rather than rebuilding one before launch.
+
+By default, 12 inspection calls or three minutes without an executable step stop
+the child with a **blocked** reason. A running native shell/check keeps its own
+timeout. Resuming a discovery stall requires concrete next-step guidance; the same
+child, user instructions, failed checks and attempt budget are retained. Plugin
+options `maxDiscoveryCalls`, `maxPlanningMs` and `progressIntervalMs` configure these
+bounds. Interrupted outgoing tool calls receive an explicitly unverified error
+result when native history omitted one; stored history and check evidence are preserved.
+
 ### Roles and models
 
 | Role | Model | Responsibility |

package/dist/asset-version.d.ts

@@ -4,5 +4,5 @@
  */
 export declare const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
 export declare const V010_RUNTIME_ASSET_VERSION = "0.10.0-v0912-language4-cost-rpt10-compaction-ref2-proposal1-review-remediation1-surface4-proposal-recovery2-quality1-terminal2-route1-path1-permission2-prerequisite1-v2-bridge1-intent1-reflection1-cancel1-proposal-budget1-goal-recovery1-delegate-execute1-v2-depth1-process-replacement1-unstarted-v2-1-cold-turn1-return-report-v2-2-root-revision1";
-export declare const V011_RUNTIME_ASSET_VERSION = "0.11.0-user-proxy-native-v3-failure-boundary";
+export declare const V011_RUNTIME_ASSET_VERSION = "0.11.2-user-proxy-execution-first-v1";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION | typeof V010_RUNTIME_ASSET_VERSION | typeof V011_RUNTIME_ASSET_VERSION;

package/dist/asset-version.js

@@ -4,4 +4,4 @@
  */
 export const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
 export const V010_RUNTIME_ASSET_VERSION = "0.10.0-v0912-language4-cost-rpt10-compaction-ref2-proposal1-review-remediation1-surface4-proposal-recovery2-quality1-terminal2-route1-path1-permission2-prerequisite1-v2-bridge1-intent1-reflection1-cancel1-proposal-budget1-goal-recovery1-delegate-execute1-v2-depth1-process-replacement1-unstarted-v2-1-cold-turn1-return-report-v2-2-root-revision1";
-export const V011_RUNTIME_ASSET_VERSION = "0.11.0-user-proxy-native-v3-failure-boundary";
+export const V011_RUNTIME_ASSET_VERSION = "0.11.2-user-proxy-execution-first-v1";

package/dist/core/work-loop.d.ts

@@ -1,3 +1,4 @@
+import { type WorkActivity, type WorkProgress } from "./work-progress.js";
 export declare const WORK_REFERENCE = "SORTIE_V011_WORK_REF ";
 export declare const WORK_LIMITS: {
     readonly attempts: 6;
@@ -6,7 +7,7 @@ export declare const WORK_LIMITS: {
     readonly checks: 128;
     readonly outputBytes: number;
 };
-export type WorkPhase = "ready" | "running" | "review" | "blocked" | "interrupted" | "completed" | "cancelled";
+export type WorkPhase = "ready" | "running" | "waiting" | "review" | "yielded" | "blocked" | "interrupted" | "completed" | "cancelled";
 export interface WorkRequest {
     id: string;
     text: string;
@@ -34,12 +35,44 @@ export interface WorkCheck {
     after: string;
     output: string;
     at: number;
+    pending?: boolean;
 }
 export interface WorkCheckReplacement {
     check: string;
     replacement: string;
     reason: string;
 }
+export interface WorkCommand {
+    id: string;
+    callID: string;
+    command: string;
+    timeout: number;
+    at: number;
+    status: "launching" | "completed" | "interrupted";
+    exit: number | null;
+    output: string;
+    nativeID?: string;
+    nativeFile?: string;
+    nativeStatus?: string;
+    retryOf?: string;
+}
+export interface WorkUsageReceipt {
+    session: string;
+    model: string;
+    tokens: number | null;
+    usd: number | null;
+    tier?: string;
+    requestedTier?: string;
+    local?: boolean;
+    pending?: boolean;
+}
+export interface WorkAuxiliaryUsage {
+    id: string;
+    root: string;
+    at: number;
+    kind: string;
+    receipt: WorkUsageReceipt;
+}
 export interface WorkState {
     version: 1;
     id: string;
@@ -54,6 +87,7 @@ export interface WorkState {
     child: string | null;
     baseline: SourceSnapshot;
     checks: WorkCheck[];
+    settledCallID?: string;
     startedAt: number;
     updatedAt: number;
     report: string;
@@ -66,11 +100,70 @@ export interface WorkState {
         intent: string;
         evidence?: string;
     };
+    sourceView?: {
+        fingerprint: string;
+        changed: string[];
+        at: number;
+    };
     checkReplacements?: WorkCheckReplacement[];
+    progress?: WorkProgress;
+    commands?: WorkCommand[];
+    controller?: {
+        path: string;
+        stopCommand?: string;
+        runID: string | null;
+        status: string;
+        input: string | null;
+        snapshot?: Record<string, unknown>;
+        notified?: boolean;
+    };
+    presentation?: {
+        id: string;
+        report: string;
+    };
+    directory?: string;
+    usage?: {
+        tokens: number | null;
+        usd: number | null;
+        models: Array<{
+            model: string;
+            tokens: number;
+        }>;
+        estimatedUsd?: number;
+        unpricedRequests?: number;
+        requests?: number;
+        meteredAt?: number;
+    };
+    userStopped?: boolean;
+    usageReceipts?: Record<string, WorkUsageReceipt>;
+    supportSessions?: Array<{
+        id: string;
+        role: string;
+    }>;
+    usageUntil?: number;
+    attemptLimit?: number;
+    attemptExtensions?: Array<{
+        at: number;
+        attempts: number;
+        limit: number;
+        evidence: string[];
+        assessment: string;
+    }>;
 }
 export interface WorkStore {
     get(key: string): Promise<unknown>;
     set(key: string, value: unknown): Promise<void>;
+    scan?(options: {
+        prefix: string;
+        after?: string;
+        limit?: number;
+    }): Promise<{
+        entries: Array<{
+            key: string;
+            value: unknown;
+        }>;
+        next?: string;
+    }>;
 }
 export declare const isRecord: (value: unknown) => value is Record<string, any>;
 /** Content identity, including new nonignored files. Git commits do not invalidate identical source. */
@@ -93,23 +186,63 @@ export declare class WorkLoop {
     private read;
     private update;
     current(root: string): Promise<WorkState | null>;
+    progress(root: string): Promise<WorkProgress | null>;
+    operatorNudge(root: string): Promise<number>;
+    usage(root: string, workID: string, usage: NonNullable<WorkState["usage"]>): Promise<void>;
+    support(root: string, id: string, role: string): Promise<void>;
+    meter(root: string, workID: string, receipts: Record<string, WorkUsageReceipt>): Promise<void>;
+    private updateUsageWork;
+    auxiliaryUsage(value: WorkAuxiliaryUsage): Promise<void>;
+    auxiliaryReceipts(root: string, since: number, until?: number): Promise<WorkAuxiliaryUsage[]>;
+    presentation(root: string, id: string, report: string): Promise<{
+        id: string;
+        report: string;
+    }>;
+    controller(root: string, path: string, snapshot?: Record<string, unknown>): Promise<void>;
+    controllerNotified(root: string): Promise<void>;
+    bindController(root: string, path: string, stopCommand: string): Promise<void>;
+    retained(): Promise<WorkState[]>;
+    private evidence;
     inspect(root: string, actor: string): Promise<{
         work: WorkState | null;
         source: SourceSnapshot;
     }>;
     observe(root: string, request: WorkRequest): Promise<void>;
-    start(root: string, instructions: string): Promise<WorkState>;
+    start(root: string, instructions: string, evidence?: string[], graceMs?: number): Promise<WorkState>;
     task(work: WorkState): {
         sessionID?: string | undefined;
         agent: string;
         description: string;
         prompt: string;
     };
+    attemptLimit(work: WorkState): number;
+    private continuationBudget;
     admit(root: string, callID: string, input: Record<string, unknown>): Promise<void>;
     claim(root: string, child: string, prompt: string): Promise<string>;
     assertWorker(root: string, child: string): Promise<WorkState>;
+    activity(root: string, child: string, activity: WorkActivity, result?: {
+        status: string;
+        exit: number | null;
+    }): Promise<void>;
+    stall(root: string, callID: string, reason: string): Promise<boolean>;
+    beginCommand(root: string, callID: string, command: string, timeout: number, retryOf?: string): Promise<{
+        command: WorkCommand;
+        launch: boolean;
+    }>;
+    nativeCommand(root: string, id: string, nativeID: string, result?: {
+        status: string;
+        exit: number | null;
+        output: string;
+        file?: string;
+    }): Promise<void>;
+    endCommand(root: string, id: string, result: {
+        exit: number | null;
+        interrupted: boolean;
+        output: string;
+        rejected?: boolean;
+    }): Promise<void>;
     check(root: string, actor: string, command: string, timeout: number, signal?: AbortSignal, execute?: typeof runWorkCheck): Promise<WorkCheck>;
     settled(root: string, callID: string, succeeded: boolean, report: string): Promise<void>;
     interrupt(root: string, cancelled?: boolean): Promise<void>;
-    review(root: string, decision: "accept" | "revise" | "blocked", assessment: string, checks: string[], replacements?: WorkCheckReplacement[]): Promise<WorkState>;
+    review(root: string, decision: "accept" | "revise" | "blocked", assessment: string, checks: string[], replacements?: WorkCheckReplacement[], graceMs?: number): Promise<WorkState>;
 }