@steerable/agent-shell 0.7.2 → 0.8.0

package/dist/host/runtime.js

@@ -21,6 +21,7 @@ import { mcpExecutor } from '../mcp-executor.js';
 import { ProjectRegistry } from '../project-registry.js';
 import { getProductConfig } from '../product-config.js';
 import { LocalBackendRouter } from '../local-backend/router.js';
+import { getLiveStream, recordGrantedEgress } from '../local-backend/live-stream.js';
 import { WorktreeService } from '../local-backend/worktree-service.js';
 import { TaskService } from '../local-backend/task-service.js';
 import { LoopPtyMonitor } from '../local-backend/loop-pty-monitor.js';
@@ -224,6 +225,27 @@ export async function createHostRuntime(options) {
                 ...(declaredLabel ? { declaredLabel } : {}),
             });
         },
+        recordEgressGrant: (prompt, decision) => {
+            if (!prompt.chatId) {
+                onLog('approval: egress grant has no chatId; not stored');
+                return;
+            }
+            const live = getLiveStream(prompt.chatId);
+            if (!live || live.status !== 'running')
+                return;
+            recordGrantedEgress(live, {
+                requestId: prompt.requestId,
+                arguments: prompt.arguments,
+                kind: decision.kind,
+                reason: decision.reason,
+            });
+        },
+        blockedCommand: (toolName, args) => {
+            if (toolName !== 'local_exec_shell')
+                return null;
+            const command = typeof args.command === 'string' ? args.command : '';
+            return localExecutor.detectDangerousCommand(command);
+        },
         outsideWorkspace: async ({ toolName, arguments: args, chatId }) => {
             if (!chatId || !localBackendRouter)
                 return false;
@@ -246,6 +268,7 @@ export async function createHostRuntime(options) {
         hasWindow,
         onLog: (line) => onLog(line),
     });
+    localBackendRouter.setAskReplay((chatId) => askUserBridge.takeResolved(chatId));
     let started = false;
     let instanceLease = null;
     let warmTimer = null;
@@ -293,7 +316,7 @@ export async function createHostRuntime(options) {
                         ...(project?.sourceFolders ?? []),
                         ...collectPackExecWritableRoots(chatId),
                         // 技能根：workflows/references/templates 是只读参考，模型必须能读
-                        // （spec_lock_reference.md 定义 pptx_layouts 怎么写，正是它被拒过）。
+                        // （技能包里的版式说明曾因读不到而被拒）。
                         ...listSkillRoots(),
                         // spill 根：工具输出过大时 sidecar 落到这里，模型要读回全文。
                         ...spillReadRoots(),

package/dist/local-backend/coreloop-stream.d.ts

@@ -37,8 +37,26 @@ export interface CoreLoopToolAction {
         category?: string;
         cached?: boolean;
         waitMs?: number;
+        auto?: boolean;
     };
 }
+/**
+ * What the sidecar knew about a failed model request, beyond its text.
+ *
+ * The host renders user-facing copy per `errorKind` and never parses
+ * `message` for it: the provider taxonomy is structured data, and message
+ * text is for the diagnostics panel.
+ */
+export interface TurnFailureInfo {
+    /** Provider classification; `undefined` when the sidecar did not send one. */
+    errorKind?: string;
+    /** Proxy the request used, credentials stripped; `undefined` means direct. */
+    proxy?: string;
+    /** Provider attempts spent on the failing request, including the last. */
+    attempts?: number;
+    /** HTTP status when the provider answered with one. */
+    statusCode?: number;
+}
 export interface CoreLoopTurnOutcome {
     status: string;
     reason?: string;
@@ -203,6 +221,13 @@ export interface StreamCoreLoopTurnOptions {
     }) => void;
     /** Fired when a tool finishes on the host (for tool-card rendering). */
     onToolAction?: (action: CoreLoopToolAction) => void;
+    /**
+     * Fired when the sidecar abandons the attempt it was streaming and starts
+     * the request again (a retry after partial output). Everything emitted via
+     * `onText` / `onReasoning` since the last restart belongs to a reply the
+     * user will never see in full and must be withdrawn from the display.
+     */
+    onRestart?: () => void;
     /** soft_timeout / budget_exhausted notices from the loop. */
     onNotice?: (kind: string, notice?: {
         kind: string;

package/dist/local-backend/coreloop-stream.js

@@ -307,6 +307,9 @@ export async function streamCoreLoopTurn(options) {
                 // for the sidecar's cancelled done.
                 if (cancelling)
                     return;
+                if (chunk.restart) {
+                    options.onRestart?.();
+                }
                 if (chunk.delta) {
                     options.onText(chunk.delta);
                 }
@@ -373,8 +376,15 @@ export async function streamCoreLoopTurn(options) {
                 // persist the partial trace — failed turns are the ones dogfooding
                 // most needs to inspect.
                 const failure = new Error(`coreloop stream failed: ${err.kind}: ${err.message}`);
+                const annotated = failure;
                 if (err.traceId)
-                    failure.traceId = err.traceId;
+                    annotated.traceId = err.traceId;
+                annotated.failureInfo = {
+                    errorKind: err.errorKind,
+                    proxy: err.proxy,
+                    attempts: err.attempts,
+                    statusCode: err.statusCode,
+                };
                 reject(failure);
             },
         })

package/dist/local-backend/live-stream.d.ts

@@ -12,7 +12,7 @@
  * 活数组引用（appendTimelineDelta / syncTimelineTools / onToolAction 都
  * 原地 mutate），因此 GET 序列化时自然读到最新状态，无需逐事件拷贝。
  */
-import type { PersistedTurnBlock } from './turn-timeline.js';
+import { type PersistedTurnBlock } from './turn-timeline.js';
 export interface LiveStreamState {
     chatId: string;
     status: 'running' | 'completed' | 'cancelled' | 'failed';
@@ -24,7 +24,16 @@ export interface LiveStreamState {
     timeline: PersistedTurnBlock[];
     /** 编排子代理生命周期事件（按到达顺序累积）。 */
     children: Array<Record<string, unknown>>;
+    /** 出网放行写入 executedActions 后通知正在看这一轮的界面。 */
+    notify?: () => void;
 }
+/** 把一次已允许的出网放行记进正在运行的回合。这不是工具结果，模型看不到。 */
+export declare function recordGrantedEgress(live: LiveStreamState, grant: {
+    requestId: string;
+    arguments: Record<string, unknown>;
+    kind: string;
+    reason: string;
+}): void;
 export declare function registerLiveStream(chatId: string, refs: {
     executedActions: Array<Record<string, unknown>>;
     timeline: PersistedTurnBlock[];

package/dist/local-backend/live-stream.js

@@ -1,4 +1,34 @@
+/**
+ * 运行中回合的「实时快照」注册表 —— 让 renderer 在切走再切回时能把正在
+ * 流式的回合重新接上（显示运行状态 + 已产出的部分内容 / 工具卡片 / 时间线）。
+ *
+ * 背景：AgentChatView 卸载时不再取消回合（回合不因切页而暂停），但该回合
+ * 的 SSE 事件只会流向当初发起 fetch 的那个组件；切回后的新组件拿不到这些
+ * 事件，只能靠轮询本注册表把「运行中 + 部分产出」恢复出来。
+ *
+ * 设计：注册表只存「正在运行」的回合。router 的 handleCoreLoopTurn 在
+ * 流开始前 register、每个产出点更新 content、结束（落库后）立即 remove。
+ * executedActions / timeline / children 三个字段存的是 router 里同名的
+ * 活数组引用（appendTimelineDelta / syncTimelineTools / onToolAction 都
+ * 原地 mutate），因此 GET 序列化时自然读到最新状态，无需逐事件拷贝。
+ */
+import { syncTimelineTools } from './turn-timeline.js';
 const liveStreams = new Map();
+/** 把一次已允许的出网放行记进正在运行的回合。这不是工具结果，模型看不到。 */
+export function recordGrantedEgress(live, grant) {
+    live.executedActions.push({
+        id: `egress-${grant.requestId}`,
+        tool: 'network_egress',
+        arguments: grant.arguments,
+        success: true,
+        approval: {
+            kind: grant.kind,
+            ...(grant.reason === 'unattended' ? { auto: true } : {}),
+        },
+    });
+    syncTimelineTools(live.timeline, live.executedActions);
+    live.notify?.();
+}
 export function registerLiveStream(chatId, refs) {
     const state = {
         chatId,

package/dist/local-backend/resumable-turn.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Which turns the `resume` channel may continue.
+ *
+ * `resume` replays the durable record's projection as the loop seed, so it can
+ * only continue a turn the record still ends mid-way through. Three settled
+ * states reach this decision, and they are not the same question:
+ *
+ * - **Interrupted** (W7-1): the process died, so the turn_active marker
+ *   survived and no terminal assistant message was written. The user message
+ *   is the record's tail; continuing finishes the request that never got an
+ *   answer.
+ * - **Failed**: the turn's last model request exhausted its retries. The
+ *   process is alive and settled the turn, so the marker is gone and the
+ *   assistant message carries `completionStatus: 'failed'`. Everything
+ *   completed before the failure is in the record — tools included — so
+ *   continuing asks the model for the next step without repeating side
+ *   effects.
+ * - **Cancelled**: the user stopped it. Continuing is allowed for the same
+ *   reason as a failure, and deliberately: the usual cause is impatience with
+ *   a retry, not a decision to abandon the task.
+ *
+ * A turn that completed normally is none of these. Resuming it would append a
+ * reply the user never asked for, which is why this is a whitelist: an
+ * unrecognised state refuses.
+ */
+/** Why a turn can be continued, as far as the store can tell. */
+export type ResumableReason = 'interrupted' | 'failed' | 'cancelled';
+export interface ResumableTurnInput {
+    /** The `turn_active` marker survived: a turn began and never settled. */
+    turnActive: boolean;
+    /** A stream for this chat is live in THIS process right now. */
+    streamActive: boolean;
+    /** Role of the chat's newest persisted message, or null on an empty chat. */
+    lastMessageRole: string | null;
+    /**
+     * `completionStatus` of the last assistant message when the store ends on
+     * one. Absent when the newest message is not an assistant reply, or when the
+     * metadata predates the field.
+     */
+    lastAssistantStatus?: string | null;
+}
+/**
+ * Returns why the chat's last turn may be continued, or null when it may not.
+ *
+ * A live stream always refuses: the turn is running, and a second writer on
+ * the same record would interleave two tails.
+ */
+export declare function resumableTurn(input: ResumableTurnInput): ResumableReason | null;

package/dist/local-backend/resumable-turn.js

@@ -0,0 +1,53 @@
+/**
+ * Which turns the `resume` channel may continue.
+ *
+ * `resume` replays the durable record's projection as the loop seed, so it can
+ * only continue a turn the record still ends mid-way through. Three settled
+ * states reach this decision, and they are not the same question:
+ *
+ * - **Interrupted** (W7-1): the process died, so the turn_active marker
+ *   survived and no terminal assistant message was written. The user message
+ *   is the record's tail; continuing finishes the request that never got an
+ *   answer.
+ * - **Failed**: the turn's last model request exhausted its retries. The
+ *   process is alive and settled the turn, so the marker is gone and the
+ *   assistant message carries `completionStatus: 'failed'`. Everything
+ *   completed before the failure is in the record — tools included — so
+ *   continuing asks the model for the next step without repeating side
+ *   effects.
+ * - **Cancelled**: the user stopped it. Continuing is allowed for the same
+ *   reason as a failure, and deliberately: the usual cause is impatience with
+ *   a retry, not a decision to abandon the task.
+ *
+ * A turn that completed normally is none of these. Resuming it would append a
+ * reply the user never asked for, which is why this is a whitelist: an
+ * unrecognised state refuses.
+ */
+/**
+ * Returns why the chat's last turn may be continued, or null when it may not.
+ *
+ * A live stream always refuses: the turn is running, and a second writer on
+ * the same record would interleave two tails.
+ */
+export function resumableTurn(input) {
+    if (input.streamActive)
+        return null;
+    if (input.turnActive) {
+        // A surviving marker with an assistant tail is the crash-between-write-
+        // and-clear window; the reply proves the turn settled, so it is not
+        // interrupted — but a failed reply may still be worth continuing.
+        return input.lastMessageRole === 'assistant'
+            ? statusReason(input.lastAssistantStatus)
+            : 'interrupted';
+    }
+    if (input.lastMessageRole !== 'assistant')
+        return null;
+    return statusReason(input.lastAssistantStatus);
+}
+function statusReason(status) {
+    if (status === 'failed')
+        return 'failed';
+    if (status === 'cancelled')
+        return 'cancelled';
+    return null;
+}

package/dist/local-backend/router.d.ts

@@ -1,5 +1,7 @@
+import { type TurnFailureInfo } from './coreloop-stream.js';
 import type { ScopedStore } from '../storage/scoped-store.js';
 import { ToolRouter } from '../tool-router.js';
+import { type ResolvedAsk } from '../sidecar/reverse-ask-user.js';
 import type { TaskService } from './task-service.js';
 import { type Principal } from '../auth/index.js';
 export interface LocalBackendRequest {
@@ -34,10 +36,14 @@ export interface WakeResult {
     status?: number;
 }
 /**
- * 把 CoreLoop/LLM 的底层错误翻译成适合直接显示在助手消息里的中文提示。
- * 原始错误仍保存在 messageMetadata.completionReason 里，便于排查。
+ * Reads the structured failure detail off a rejected stream.
+ *
+ * `streamCoreLoopTurn` annotates its rejection; anything else (an abort, a
+ * router-level error) carries none, which the renderer shows as its generic
+ * card. Returns undefined rather than an empty object so the persisted
+ * metadata omits the field entirely.
  */
-export declare function userFacingCoreLoopFailure(reason: string): string;
+export declare function readTurnFailureInfo(err: unknown): TurnFailureInfo | undefined;
 export interface StreamOptions {
     /**
      * 取消信号。renderer 主动 Stop、窗口被销毁、应用退出时由 main 进程 abort。
@@ -46,6 +52,37 @@ export interface StreamOptions {
      */
     signal?: AbortSignal;
 }
+/**
+ * Extracts the fields a "reconnecting" indicator needs from a retry notice.
+ *
+ * The loop announces every retry as a `hook_action`; only attempts on the
+ * same model request are a wait the user notices, so the round and delay are
+ * carried through. Returns null for any other hook action so the caller can
+ * keep its round-boundary handling unchanged.
+ */
+/**
+ * `completionStatus` of a persisted assistant message, or null.
+ *
+ * Only the terminal assistant message's status decides whether Continue is
+ * offered, so this reads the field and leaves the meaning to
+ * `resumableTurn`. A message without metadata (older builds) yields null,
+ * which refuses — resuming a turn whose end state is unknown could append a
+ * reply to a conversation that already finished.
+ */
+export declare function readCompletionStatus(message: {
+    messageMetadata?: string | null;
+} | undefined): string | null;
+export declare function readRetryNotice(notice: {
+    kind?: string;
+    action?: unknown;
+    delayMs?: unknown;
+    round?: unknown;
+    reason?: unknown;
+} | undefined): {
+    round?: number;
+    delayMs?: number;
+    reason?: string;
+} | null;
 /**
  * Out-of-band 事件推送回调。用于把"在请求生命周期之外"才出结果的事件（例如
  * 后台 AI 标题生成）异步广播到所有 renderer。main.ts 注入 `webContents.send`
@@ -60,12 +97,15 @@ export declare class LocalBackendRouter {
     private readonly broadcast;
     /** 4.6a/4.6c：任务面板的路由入口（列表 + 合并/丢弃）。未注入时任务路由 503。 */
     private readonly taskService;
+    private takeAskReplay;
     constructor(toolRouter: ToolRouter, options: {
         store: ScopedStore;
         resolveStore?: (principal?: Principal) => ScopedStore;
         broadcast?: LocalBackendBroadcast;
         taskService?: TaskService;
     });
+    /** The host records each answered ask; the following tool row stores that text. */
+    setAskReplay(take: (chatId: string) => ResolvedAsk | undefined): void;
     private get store();
     /** Store selected for the active request, or the host default outside one. */
     get activeStore(): ScopedStore;