@steerable/agent-shell 0.6.65 → 0.6.67

package/dist/host/runtime.js

@@ -32,6 +32,7 @@ import { startHostSidecar, shutdownHostSidecar } from '../sidecar/boot.js';
 import { createVisibleTerminalExec } from './visible-terminal-exec.js';
 import { createJsonStore } from '../json-store.js';
 import { bindWorkspaceSkillRoots } from '../local-backend/skill-loader.js';
+import { collectPackExecWritableRoots } from '../local-backend/pack-turn-hooks.js';
 import { getChatAttachmentsDir } from '../attachments.js';
 import { ensureChatWorkspace } from '../project-home.js';
 import { recordInsightTurn } from '../insights/record.js';
@@ -236,8 +237,7 @@ export async function createHostRuntime(options) {
                 store: defaultStore,
                 toolRouter,
                 resolveProjectRoot: async (chatId) => localBackendRouter.resolveChatWorkspaceRoot(chatId),
-                // 读：项目家目录之外，附件目录和源文件夹（含各自子目录）也可读。
-                // 写：源文件夹及其子目录与家目录同一档；附件目录保持只读。
+                // 写：源文件夹、包声明的可写根，以及各自的子目录。附件目录保持只读。
                 resolveAdditionalReadRoots: async (chatId) => {
                     const project = await localBackendRouter.resolveChatProject(chatId);
                     return [
@@ -247,7 +247,10 @@ export async function createHostRuntime(options) {
                 },
                 resolveAdditionalWriteRoots: async (chatId) => {
                     const project = await localBackendRouter.resolveChatProject(chatId);
-                    return project?.sourceFolders ?? [];
+                    return [
+                        ...(project?.sourceFolders ?? []),
+                        ...collectPackExecWritableRoots(chatId),
+                    ];
                 },
                 approvalHandler: approvalBridge.handler,
                 askUserHandler: askUserBridge.handler,

package/dist/host-tools.d.ts

@@ -34,7 +34,7 @@ export type ResolvedSettingsChrome = Record<SettingsItemId, boolean>;
  */
 export declare function resolveSettingsChrome(value?: unknown, tools?: ResolvedHostTools): ResolvedSettingsChrome;
 export declare function hasGeneralSettingsChrome(chrome?: ResolvedSettingsChrome): boolean;
-export declare const LOCAL_FS_TOOL_NAMES: readonly ["local_exec_shell", "local_read_file", "view_image", "local_write_file", "local_edit_file", "present_files", "local_open_path", "local_run_snippet", "local_list_scripts", "local_run_script", "grep", "glob", "pwsh"];
+export declare const LOCAL_FS_TOOL_NAMES: readonly ["local_exec_shell", "write_stdin", "local_read_file", "view_image", "local_write_file", "local_edit_file", "present_files", "local_open_path", "local_run_snippet", "local_list_scripts", "local_run_script", "grep", "glob", "pwsh"];
 export declare function resolveHostToolSurface(value: boolean | {
     capability?: boolean;
     chrome?: boolean;

package/dist/host-tools.js

@@ -75,6 +75,7 @@ export function hasGeneralSettingsChrome(chrome = resolveSettingsChrome()) {
 }
 export const LOCAL_FS_TOOL_NAMES = [
     'local_exec_shell',
+    'write_stdin',
     'local_read_file',
     'view_image',
     'local_write_file',

package/dist/local-backend/router.js

@@ -72,6 +72,18 @@ function parseSourceFolders(value) {
         .filter((item) => typeof item === 'string' && item.trim() !== '')
         .map(expandUserPath);
 }
+/** 拖拽排序的 id 列表。不是字符串数组时返回 null，由路由回 400。 */
+function readProjectOrderIds(value) {
+    if (!Array.isArray(value))
+        return null;
+    const ids = [];
+    for (const item of value) {
+        if (typeof item !== 'string' || item.trim() === '')
+            return null;
+        ids.push(item.trim());
+    }
+    return ids;
+}
 /**
  * 把 CoreLoop/LLM 的底层错误翻译成适合直接显示在助手消息里的中文提示。
  * 原始错误仍保存在 messageMetadata.completionReason 里，便于排查。
@@ -582,6 +594,20 @@ export class LocalBackendRouter {
                 }
             }
         }
+        if (pathname === '/api/v2/projects/order' && method === 'PUT') {
+            const registry = this.toolRouter.projectRegistry;
+            if (!registry) {
+                return { status: 503, data: { error: '项目注册表不可用' } };
+            }
+            const orderedIds = readProjectOrderIds(this.toRecord(request.body).orderedIds);
+            if (!orderedIds) {
+                return { status: 400, data: { error: 'orderedIds 必须是项目 id 列表' } };
+            }
+            return {
+                status: 200,
+                data: { success: true, projects: registry.reorder(orderedIds) },
+            };
+        }
         const projectMatch = pathname.match(/^\/api\/v2\/projects\/([^/]+)$/);
         if (projectMatch) {
             const projectId = decodeURIComponent(projectMatch[1]);

package/dist/local-backend/skills/85-local-exec/SKILL.md

@@ -32,6 +32,7 @@ match: any
 
 - **超时 ≠ 失败，严禁原样重跑启动命令**：返回里出现 `timedOut: true` 时，只是 shell 等待被掐断——如果命令是启动 GUI / 长时间运行的程序（如 Qt 界面软件），该程序**很可能仍在运行**，用户可能正在里面操作。此时**不要**再次执行同一条启动命令（会把程序重复启动多次）。正确做法：先确认进程是否在运行（如 `Get-Process`）；确实需要长时间等待时传更大的 `timeout` 参数；启动 GUI 程序时优先用不阻塞的方式（PowerShell `Start-Process "app.exe"`），启动成功即视为完成，不要等它退出。
 - **GUI 启动命令的特殊约定**：命令行里带独立的 `gui` 字样（如 `xxx.exe gui replay ...`、`--gui`）会被识别为"启动 GUI 程序"。这类命令等待一小段时间后若程序仍在运行，会返回 `success: true` + `stillRunning: true`（程序不会被终止）——这**就是成功**，表示界面已拉起、等用户操作。看到 `stillRunning: true` 后直接向用户汇报"程序已启动，请在界面中操作"，**绝对不要**再次执行同一条命令。
+- **交互命令续同一会话**：需要读提示再输入（安装向导、REPL、`ssh` 口令之外的交互程序）时，给 `local_exec_shell` 传 `yieldMs`（毫秒）。进程还在跑时返回 `stillRunning: true` 和 `sessionId`，**不要**把这次返回当成超时失败，也**不要**再开一条新命令重跑。下一步用 `write_stdin`：`sessionId` 原样带回，`chars` 是要写入的输入（含回车），`yieldMs` 等新输出。只想看新输出时 `chars` 传空字符串。`write_stdin` 只返回上次之后的新输出。会话不存在时停止重试。不传 `yieldMs` 的命令仍等到退出或超时，超时行为不变。
 
 ## 真实执行纪律
 

package/dist/local-executor.d.ts

@@ -11,6 +11,11 @@ export interface LocalExecRequest {
     shell?: ShellType;
     /** 在伪终端里跑。缺省走管道，调用方要终端语义时显式打开。 */
     pty?: boolean;
+    /**
+     * 设了就在这么多毫秒后返回，进程还在就留下 sessionId。
+     * 不设则跟原来一样，等到退出或超时。
+     */
+    yieldMs?: number;
     /** 用户已经批准一次 prompt 决定。不能放过 forbidden。 */
     execApproval?: 'allow';
 }
@@ -38,6 +43,8 @@ export interface LocalExecResult {
     transport?: 'local' | 'ssh';
     /** 这次启动是否分配了伪终端。 */
     pty?: boolean;
+    /** yieldMs 留下的还在运行的伪终端。下一步用 write_stdin 写入或只取新输出。 */
+    sessionId?: string;
 }
 export interface LocalFileReadRequest {
     path: string;
@@ -249,6 +256,7 @@ export declare class LocalExecutor {
     executeShell(request: LocalExecRequest): Promise<LocalExecResult>;
     private holdForExecPolicy;
     private runPlannedShell;
+    private runYieldedPty;
     readLocalFile(request: LocalFileReadRequest, projectRoot?: string | null, additionalReadRoots?: string[] | null): Promise<LocalFileReadResult>;
     writeLocalFile(request: LocalFileWriteRequest, projectRoot?: string | null, additionalWriteRoots?: string[] | null): Promise<LocalFileWriteResult>;
     /**

package/dist/local-executor.js

@@ -9,6 +9,7 @@ import { constants as fsConstants } from 'fs';
 import { adaptCommandForPowerShell } from './shell-adapt.js';
 import { evaluateExecPolicy, planSshArgv, } from './shell-exec.js';
 import { nodeShellBackend } from './shell-process.js';
+import { closeShellSession, readShellSession, shellSessionStatus, startPtySession, } from './shell-session.js';
 import { applyEdits, EditError } from './local-edit.js';
 // `he` ships as CommonJS and does not expose ESM named exports, so we have to
 // take the default import and destructure at runtime in this ESM module.
@@ -572,6 +573,14 @@ export class LocalExecutor {
             spec.cwd = os.homedir();
             spec.env = stringEnv();
         }
+        const yieldMs = input.request.yieldMs;
+        if (pty &&
+            !input.useSsh &&
+            !this.shellBackend &&
+            typeof yieldMs === 'number' &&
+            Number.isFinite(yieldMs)) {
+            return await this.runYieldedPty(spec, input.resolvedShell.type, yieldMs);
+        }
         const backend = this.shellBackend ?? nodeShellBackend;
         const outcome = await backend.run(spec, {
             timeoutMs: input.timeout,
@@ -603,6 +612,31 @@ export class LocalExecutor {
             pty: spec.pty,
         };
     }
+    async runYieldedPty(spec, shell, yieldMs) {
+        const sessionId = startPtySession({
+            file: spec.file,
+            args: spec.args,
+            cwd: spec.cwd,
+            env: spec.env,
+            maxOutputBytes: this.maxOutputBytes,
+        });
+        const stdout = (await readShellSession(sessionId, yieldMs)) ?? '';
+        const status = shellSessionStatus(sessionId);
+        const base = {
+            stdout,
+            stderr: '',
+            shell,
+            platform: process.platform,
+            transport: 'local',
+            pty: true,
+        };
+        if (!status?.running) {
+            const exitCode = status?.exitCode ?? -1;
+            closeShellSession(sessionId);
+            return { ...base, success: exitCode === 0, exitCode };
+        }
+        return { ...base, success: true, stillRunning: true, sessionId };
+    }
     async readLocalFile(request, projectRoot, additionalReadRoots) {
         try {
             const filePath = this.resolvePath(request.path);

package/dist/project-registry.d.ts

@@ -30,6 +30,11 @@ export interface ProjectRecord {
      * 旧记录没有此字段，读取时按 `false` 处理（见 {@link ProjectRegistry.isTrusted}）。
      */
     trusted?: boolean;
+    /**
+     * 侧边栏显示顺序，越小越靠前。旧记录没有此字段时按 createdAt 升序。
+     * 用户拖拽排序后每个项目都会写上序号；之后新建的项目没有序号，排在已编号项目之后。
+     */
+    sortOrder?: number;
     createdAt: string;
     updatedAt: string;
 }
@@ -51,6 +56,11 @@ export declare class ProjectRegistry {
     create(input: CreateProjectInput): ProjectRecord;
     update(id: string, updates: Partial<CreateProjectInput>): ProjectRecord;
     delete(id: string): boolean;
+    /**
+     * 按 orderedIds 重排侧边栏。未出现的 id 忽略；名单里没提到的项目
+     * 保持相对顺序接在后面。写入连续的 sortOrder，list() 随后按该序号返回。
+     */
+    reorder(orderedIds: readonly string[]): ProjectRecord[];
     /**
      * W6-5: read the trust flag, defaulting absent (legacy) records to
      * `false` — fail-closed, so a project is never trusted unless the user

package/dist/project-registry.js

@@ -19,8 +19,9 @@ export class ProjectRegistry {
         this.store = store;
     }
     list() {
-        // 按创建时间升序：侧边栏项目组顺序稳定，早建的在前。
-        return [...(this.store.get(STORE_KEY) ?? [])].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+        // 拖过序的记录按 sortOrder；没有序号的旧记录仍按创建时间升序，
+        // 并且排在已编号项目之后（新建项目因此出现在列表末尾）。
+        return [...(this.store.get(STORE_KEY) ?? [])].sort(compareProjects);
     }
     get(idOrName) {
         const needle = idOrName.trim().toLowerCase();
@@ -87,6 +88,33 @@ export class ProjectRegistry {
         this.store.set(STORE_KEY, next);
         return true;
     }
+    /**
+     * 按 orderedIds 重排侧边栏。未出现的 id 忽略；名单里没提到的项目
+     * 保持相对顺序接在后面。写入连续的 sortOrder，list() 随后按该序号返回。
+     */
+    reorder(orderedIds) {
+        const current = this.list();
+        const byId = new Map(current.map((project) => [project.id, project]));
+        const next = [];
+        const seen = new Set();
+        for (const id of orderedIds) {
+            const project = byId.get(id);
+            if (!project || seen.has(id))
+                continue;
+            seen.add(id);
+            next.push(project);
+        }
+        for (const project of current) {
+            if (!seen.has(project.id))
+                next.push(project);
+        }
+        const stamped = next.map((project, index) => ({
+            ...project,
+            sortOrder: index,
+        }));
+        this.store.set(STORE_KEY, stamped);
+        return stamped;
+    }
     /**
      * W6-5: read the trust flag, defaulting absent (legacy) records to
      * `false` — fail-closed, so a project is never trusted unless the user
@@ -111,6 +139,21 @@ export class ProjectRegistry {
         return next;
     }
 }
+function compareProjects(a, b) {
+    const aOrder = finiteSortOrder(a.sortOrder);
+    const bOrder = finiteSortOrder(b.sortOrder);
+    if (aOrder !== null && bOrder !== null && aOrder !== bOrder)
+        return aOrder - bOrder;
+    if ((aOrder !== null) !== (bOrder !== null))
+        return aOrder !== null ? -1 : 1;
+    const byCreated = a.createdAt.localeCompare(b.createdAt);
+    if (byCreated !== 0)
+        return byCreated;
+    return a.id.localeCompare(b.id);
+}
+function finiteSortOrder(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
 function normalizeSourceFolders(folders, homePath) {
     const home = homePath.trim();
     const seen = new Set();

package/dist/shell-session.d.ts

@@ -0,0 +1,37 @@
+export interface ShellSessionStatus {
+    running: boolean;
+    exitCode: number | null;
+}
+export interface ShellSessionUpdate {
+    success: boolean;
+    stdout: string;
+    running: boolean;
+    exitCode: number | null;
+    error?: string;
+    truncated?: boolean;
+}
+/** 打开一个伪终端并记下会话号。调用方负责之后用 read / write 取输出。 */
+export declare function startPtySession(spec: {
+    file: string;
+    args: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    maxOutputBytes: number;
+}): string;
+export declare function shellSessionStatus(sessionId: string): ShellSessionStatus | null;
+/** 等到有一段新输出安静下来、进程退出，或到达 yieldMs。返回这段新输出。 */
+export declare function readShellSession(sessionId: string, waitMs: number): Promise<string | null>;
+export declare function writeShellSessionChars(sessionId: string, chars: string): {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function writeShellStdin(input: {
+    sessionId: string;
+    chars: string;
+    yieldMs: number;
+}): Promise<ShellSessionUpdate>;
+export declare function closeShellSession(sessionId: string): void;
+/** 测试收尾：关掉还留着的伪终端。 */
+export declare function closeAllShellSessions(): void;

package/dist/shell-session.js

@@ -0,0 +1,169 @@
+/**
+ * 还在跑的伪终端会话。
+ * local_exec_shell 带 yieldMs 时把进程留在这里；write_stdin 按会话号写入，或只取新输出。
+ */
+import { randomUUID } from 'node:crypto';
+import * as pty from 'node-pty';
+import { stripAnsi } from './shell-process.js';
+const MAX_SESSION_MS = 10 * 60 * 1000;
+const QUIET_MS = 200;
+const MAX_YIELD_MS = 120_000;
+const sessions = new Map();
+function stringEnv(env) {
+    const next = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (typeof value === 'string')
+            next[key] = value;
+    }
+    if (env)
+        Object.assign(next, env);
+    next.TERM = 'xterm-256color';
+    return next;
+}
+function takeNew(live) {
+    const fresh = stripAnsi(live.raw.slice(live.cursor));
+    live.cursor = live.raw.length;
+    return fresh;
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+/** 打开一个伪终端并记下会话号。调用方负责之后用 read / write 取输出。 */
+export function startPtySession(spec) {
+    const id = randomUUID();
+    const proc = pty.spawn(spec.file, spec.args, {
+        name: 'xterm-256color',
+        cols: 120,
+        rows: 30,
+        cwd: spec.cwd,
+        env: stringEnv(spec.env),
+    });
+    const live = {
+        id,
+        proc,
+        raw: '',
+        cursor: 0,
+        exitCode: null,
+        truncated: false,
+        timer: setTimeout(() => {
+            try {
+                proc.kill();
+            }
+            catch (err) {
+                if (!(err instanceof Error))
+                    throw err;
+            }
+        }, MAX_SESSION_MS),
+    };
+    live.timer.unref?.();
+    proc.onData((chunk) => {
+        const next = live.raw + chunk;
+        if (Buffer.byteLength(next) > spec.maxOutputBytes) {
+            live.truncated = true;
+            live.raw = Buffer.from(next).subarray(0, spec.maxOutputBytes).toString('utf-8');
+            return;
+        }
+        live.raw = next;
+    });
+    proc.onExit(({ exitCode }) => {
+        live.exitCode = exitCode ?? -1;
+        clearTimeout(live.timer);
+    });
+    sessions.set(id, live);
+    return id;
+}
+export function shellSessionStatus(sessionId) {
+    const live = sessions.get(sessionId);
+    if (!live)
+        return null;
+    return { running: live.exitCode === null, exitCode: live.exitCode };
+}
+/** 等到有一段新输出安静下来、进程退出，或到达 yieldMs。返回这段新输出。 */
+export async function readShellSession(sessionId, waitMs) {
+    const live = sessions.get(sessionId);
+    if (!live)
+        return null;
+    const cap = Math.max(0, Math.min(waitMs, MAX_YIELD_MS));
+    const started = Date.now();
+    let lastLen = live.raw.length;
+    let lastChange = started;
+    while (Date.now() - started < cap) {
+        if (live.exitCode !== null)
+            break;
+        if (live.raw.length !== lastLen) {
+            lastLen = live.raw.length;
+            lastChange = Date.now();
+        }
+        else if (lastLen > live.cursor && Date.now() - lastChange >= QUIET_MS) {
+            break;
+        }
+        await delay(20);
+    }
+    return takeNew(live);
+}
+export function writeShellSessionChars(sessionId, chars) {
+    const live = sessions.get(sessionId);
+    if (!live)
+        return { ok: false, error: 'session not found' };
+    if (live.exitCode !== null)
+        return { ok: true };
+    try {
+        live.proc.write(chars);
+        return { ok: true };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { ok: false, error: message || 'failed to write stdin' };
+    }
+}
+export async function writeShellStdin(input) {
+    const sessionId = input.sessionId.trim();
+    if (!sessionId)
+        return { success: false, stdout: '', running: false, exitCode: null, error: 'sessionId is required' };
+    const existing = shellSessionStatus(sessionId);
+    if (!existing) {
+        return { success: false, stdout: '', running: false, exitCode: null, error: 'session not found' };
+    }
+    if (input.chars && existing.running) {
+        const wrote = writeShellSessionChars(sessionId, input.chars);
+        if (!wrote.ok) {
+            return { success: false, stdout: '', running: existing.running, exitCode: existing.exitCode, error: wrote.error };
+        }
+    }
+    const stdout = await readShellSession(sessionId, input.yieldMs);
+    const after = shellSessionStatus(sessionId);
+    if (stdout === null || !after) {
+        return { success: false, stdout: '', running: false, exitCode: null, error: 'session not found' };
+    }
+    const live = sessions.get(sessionId);
+    return {
+        success: true,
+        stdout,
+        running: after.running,
+        exitCode: after.exitCode,
+        ...(live?.truncated ? { truncated: true } : {}),
+    };
+}
+export function closeShellSession(sessionId) {
+    const live = sessions.get(sessionId);
+    if (!live)
+        return;
+    sessions.delete(sessionId);
+    clearTimeout(live.timer);
+    if (live.exitCode === null) {
+        try {
+            live.proc.kill();
+        }
+        catch (err) {
+            if (!(err instanceof Error))
+                throw err;
+        }
+    }
+}
+/** 测试收尾：关掉还留着的伪终端。 */
+export function closeAllShellSessions() {
+    for (const id of [...sessions.keys()])
+        closeShellSession(id);
+}

package/dist/tool-router.js

@@ -1,6 +1,7 @@
 import os from 'node:os';
 import path from 'node:path';
 import { buildProjectRootViolation, expandFencePath, isPathWithinRoot, writableFenceRoots, writableFenceViolation, } from './local-executor.js';
+import { writeShellStdin } from './shell-session.js';
 import { mcpExecutor } from './mcp-executor.js';
 import { rankTools, resolveMaxResults, TOOL_SEARCH_DEFAULT_MAX_RESULTS, } from './tool-search-rank.js';
 import { maybeAutoInstallWrittenSkill } from './local-backend/skill-install.js';
@@ -186,6 +187,8 @@ export class ToolRouter {
             {
                 name: 'local_exec_shell',
                 description: 'Execute a shell command in a pseudo-terminal. Set pty to false for a plain pipe. ' +
+                    'Set yieldMs to return while the command is still running; the result includes sessionId. ' +
+                    'Continue that same session with write_stdin (write input, or pass empty chars to poll new output). ' +
                     'When this host is configured with a remote endpoint, the command runs on that host instead of this machine.',
                 mode: 'destructive',
                 inputSchema: {
@@ -195,10 +198,33 @@ export class ToolRouter {
                         cwd: { type: 'string' },
                         timeout: { type: 'number', description: 'Timeout in milliseconds (e.g. 30000). If a small number like 15 or 30 is provided, it is assumed to be in seconds and automatically multiplied by 1000.' },
                         pty: { type: 'boolean', description: 'Run in a pseudo-terminal. Defaults to true.' },
+                        yieldMs: {
+                            type: 'number',
+                            description: 'Return after this many milliseconds if the command is still running, and include sessionId for write_stdin. Omit to wait until exit or timeout.',
+                        },
                     },
                     required: ['command'],
                 },
             },
+            {
+                name: 'write_stdin',
+                description: 'Write more input to a running local_exec_shell session, or poll its new output. ' +
+                    'Pass the sessionId from that command. chars is sent to the terminal; omit it or pass an empty string to only collect output that arrived since the last call. ' +
+                    'Does not start a new command and does not ask for approval again.',
+                mode: 'local',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        sessionId: { type: 'string', description: 'sessionId returned by local_exec_shell.' },
+                        chars: { type: 'string', description: 'Input to write. Empty string polls new output only.' },
+                        yieldMs: {
+                            type: 'number',
+                            description: 'How long to wait for new output, in milliseconds. Defaults to 1000.',
+                        },
+                    },
+                    required: ['sessionId'],
+                },
+            },
             {
                 name: 'local_read_file',
                 description: 'Read a local text file. Large files can be paged with offset/limit (1-based line numbers); ' +
@@ -956,7 +982,14 @@ export class ToolRouter {
                     cwd: typeof args.cwd === 'string' ? args.cwd : undefined,
                     timeout: typeof args.timeout === 'number' ? args.timeout : undefined,
                     pty: args.pty !== false,
+                    yieldMs: typeof args.yieldMs === 'number' ? args.yieldMs : undefined,
                 }, projectRoot, context?.additionalWriteRoots ?? null);
+            case 'write_stdin':
+                return await writeShellStdin({
+                    sessionId: typeof args.sessionId === 'string' ? args.sessionId : '',
+                    chars: typeof args.chars === 'string' ? args.chars : '',
+                    yieldMs: typeof args.yieldMs === 'number' ? args.yieldMs : 1000,
+                });
             case 'local_read_file':
                 return await this.localExecutor.readLocalFile({
                     path: String(args.path || ''),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steerable/agent-shell",
-  "version": "0.6.65",
+  "version": "0.6.67",
   "description": "Steerable framework — product-neutral Node HostRuntime and headless HTTP server shared by Tauri desktop and browser deployments; scenario packs extend it through @steerable/pack-sdk.",
   "license": "Apache-2.0",
   "homepage": "https://steerableframework.com/",
@@ -53,9 +53,9 @@
     "jpeg-js": "^0.4.4",
     "node-pty": "^1.1.0",
     "pngjs": "^7.0.0",
-    "@steerable/agent-protocol": "0.6.65",
-    "@steerable/agent-harness": "0.6.65",
-    "@steerable/pack-sdk": "0.6.65"
+    "@steerable/agent-harness": "0.6.67",
+    "@steerable/agent-protocol": "0.6.67",
+    "@steerable/pack-sdk": "0.6.67"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",