@steerable/agent-shell 0.6.26 → 0.6.28

package/dist/local-backend/ai-suggestions.d.ts

@@ -1,52 +1,34 @@
 /**
- * 回合结束后生成「下一轮用户输入」建议（WorkBuddy 式快捷追问）。
+ * 回合结束后生成「下一轮用户输入」建议。
  *
- * 主路径走一次短 LLM 调用。优先消化用户/工作区技能和助手回复里已经写明的
- * 下一步（编号列表、脚本调用、推荐后续），条数跟真实下一步走，不凑 3 条。
- * 没有可执行下一步时，才用启发式兜底（PPT / 计划 / 代码 / 通用）。永不抛错。
+ * 只走一次短 LLM 调用。判断来源只有助手给用户的下一步：
+ * `[next_steps]...[/next_steps]` 标签，或回复最后一段里的建议。
+ * 不做规则抽取、不按 PPT/计划/代码套模板。永不抛错。
  *
- * 调用方应该 fire-and-forget：先把兜底推上 UI，LLM 成功后再替换。
+ * 调用方应该 fire-and-forget，且只广播一次最终结果。
  * 不要挂在 SSE 主流程里阻塞 `[DONE]`。
  */
 export declare const SUGGESTED_REPLY_MAX = 8;
-/** 去掉脚本调用、绝对路径，留下用户能点的短标题。 */
-export declare function stripSkillInvocation(raw: string): string;
-/** 单条建议清洗：去编号/引号、压空白、截断。不合格返回空串。 */
-export declare function cleanSuggestedReply(raw: string): string;
 /**
- * 从技能正文抽出「下一步 / 后续 / Next steps」节里的列表项。
- * 兼容用户自建技能：标题不固定，脚本调用行只保留标题。
+ * 建议芯片的判断来源：有 `[next_steps]` 用最后一段标签正文，否则用回复最后一段。
  */
-export declare function extractSkillNextSteps(content: string): string[];
-/**
- * 从助手回复抽出已列出的下一步。先看「下一步」类标题，再看末尾带脚本调用的编号列表。
- */
-export declare function extractListedNextSteps(text: string): string[];
+export declare function extractNextStepsSource(assistantText: string): string;
+/** 单条建议清洗：去编号/引号、压空白、截断。不合格返回空串。 */
+export declare function cleanSuggestedReply(raw: string): string;
 /**
  * 从模型原文抽出建议。接受 JSON 数组、markdown 代码块、或编号/项目列表。
  * 最多 {@link SUGGESTED_REPLY_MAX} 条。
  */
 export declare function parseSuggestedReplies(raw: string): string[];
-export interface FallbackSuggestedRepliesOptions {
-    /** 用户/工作区技能正文（可多份）。会从中抽出「下一步」节。 */
-    skillContents?: string[];
-}
-/**
- * 不调模型的建议。技能或回复里已有下一步时原样采用（条数不固定），
- * 否则回落到启发式句子。
- */
-export declare function fallbackSuggestedReplies(userText: string, assistantText: string, opts?: FallbackSuggestedRepliesOptions): string[];
 export interface GenerateSuggestedRepliesResult {
     suggestions: string[];
-    /** true = LLM 失败或输出不合格，且没有从技能/回复抽出下一步，suggestions 来自启发式兜底。 */
+    /** true = LLM 失败、超时或输出不合格；suggestions 为空。空数组本身算有效判断。 */
     usedFallback: boolean;
 }
 export interface GenerateSuggestedRepliesOptions {
     perAttemptTimeoutMs?: number;
-    /** 用户/工作区技能正文。生成器只抽「下一步」节，不依赖内置技能。 */
-    skillContents?: string[];
 }
 /**
- * 生成本轮追问建议。永不抛错；有技能/回复下一步时按实际条数返回。
+ * 生成本轮追问建议。永不抛错；没有下一步来源或模型判定没有下一步时返回空数组。
  */
 export declare function generateSuggestedReplies(userText: string, assistantText: string, opts?: GenerateSuggestedRepliesOptions): Promise<GenerateSuggestedRepliesResult>;

package/dist/local-backend/ai-suggestions.js

@@ -1,39 +1,32 @@
 /**
- * 回合结束后生成「下一轮用户输入」建议（WorkBuddy 式快捷追问）。
+ * 回合结束后生成「下一轮用户输入」建议。
  *
- * 主路径走一次短 LLM 调用。优先消化用户/工作区技能和助手回复里已经写明的
- * 下一步（编号列表、脚本调用、推荐后续），条数跟真实下一步走，不凑 3 条。
- * 没有可执行下一步时，才用启发式兜底（PPT / 计划 / 代码 / 通用）。永不抛错。
+ * 只走一次短 LLM 调用。判断来源只有助手给用户的下一步：
+ * `[next_steps]...[/next_steps]` 标签，或回复最后一段里的建议。
+ * 不做规则抽取、不按 PPT/计划/代码套模板。永不抛错。
  *
- * 调用方应该 fire-and-forget：先把兜底推上 UI，LLM 成功后再替换。
+ * 调用方应该 fire-and-forget，且只广播一次最终结果。
  * 不要挂在 SSE 主流程里阻塞 `[DONE]`。
  */
 import { llmService } from '../llm/index.js';
 export const SUGGESTED_REPLY_MAX = 8;
 const MAX_SUGGESTION_CHARS = 48;
 const USER_TEXT_LIMIT = 500;
-const ASSISTANT_HEAD_LIMIT = 800;
-const ASSISTANT_TAIL_LIMIT = 2000;
-const SKILL_EXCERPT_LIMIT = 4000;
-const SYSTEM_PROMPT = `你是对话追问建议助手。根据用户上一轮请求、助手刚刚完成的回复，以及用户技能里写明的下一步，生成用户点一下就能发出去的下一轮输入。
+const SOURCE_LIMIT = 2000;
+const NEXT_STEPS_BLOCK_RE = /\[next_steps\]([\s\S]*?)\[\/next_steps\]/gi;
+const SYSTEM_PROMPT = `你是对话追问建议助手。根据「下一步来源」判断用户点一下就能发出去的下一轮输入。
+
+下一步来源只有两种：
+- [next_steps]...[/next_steps] 标签里的内容
+- 否则是助手回复的最后一段
 
 要求：
-1. 条数不固定：有几条真实的下一步就给几条，最少 1 条，最多 8 条。不要为了凑数编造，也不要无故压成 3 条。
-2. 优先使用「用户技能中的下一步」和助手回复末尾已经列出的后续动作（编号列表、脚本调用、推荐后续）。把它们改写成用户口吻的短指令，保留层位、对象、参数等关键信息，不要丢掉技能里的具体动作。
-3. 助手本轮已经做完的步骤不要再建议；技能里写了但还没做的后续必须出现。
-4. 每条 6-40 个字，像用户会打的话。不要空泛的「再详细说说」「告诉我下一步怎么做」。
-5. 不要编号、不要引号、不要解释、不要附带命令行或绝对路径。
-6. 只输出 JSON 字符串数组，例如 ["画接底层的井密度交会图","统计这口井的有效厚度","补一张气层厚度等值线"]`;
-const NEXT_STEP_WORDS = '下一步(?:动作|操作|工作)?|后续(?:步骤|工作|动作|操作|可做)?|建议(?:的)?(?:下一步|继续|操作)?|可以继续|推荐(?:的)?(?:后续|操作|下一步)?|next\\s*steps?';
-/** 整行即「下一步」类标题：可带 #/** 前缀、括号补充说明（如「后续动作（可点选）」）、结尾冒号。 */
-const NEXT_STEP_HEADING_RE = new RegExp(`^(?:#{1,6}\\s*)?(?:\\*\\*)?(?:${NEXT_STEP_WORDS})(?:\\s*[（(][^）)]*[）)])?\\s*(?:\\*\\*)?\\s*[:：]?$`, 'i');
-/**
- * 短引导行，如「完成后可以继续：」。必须以关键词加冒号收尾且整行够短——
- * 否则「以上是我的建议」这类普通句尾会被当成标题，把后面无关的列表抽成建议。
- */
-const NEXT_STEP_LEAD_IN_RE = new RegExp(`(?:${NEXT_STEP_WORDS})\\s*[:：]$`, 'i');
-const NEXT_STEP_LEAD_IN_MAX_CHARS = 16;
-// 列表标记后必须有空白，否则 PowerShell 参数（-Action）会被当成列表项。
+1. 只把「用户可以接着做的下一步」改写成用户口吻的短指令。
+2. 本轮已完成的汇报（文件位置、页数、设计风格、内容结构、摘要、目录、生平/作品列表）不是下一步。来源不是给用户的下一步时，输出空数组 []。
+3. 不要编造，不要用「继续完善这份结果」「告诉我下一步怎么做」这类套话凑数。
+4. 有几条真实下一步就给几条，最少 0 条，最多 8 条。
+5. 每条 6-40 个字。不要编号、不要引号、不要解释、不要附带命令行或绝对路径。
+6. 只输出 JSON 字符串数组，例如 ["把封面改成深蓝商务风","第2页个人简介写具体"]`;
 const LIST_ITEM_RE = /^(?:\d+[.)、]|[-*•])\s+(\S.*)$/;
 function withTimeout(promise, timeoutMs, label) {
     if (timeoutMs <= 0)
@@ -57,54 +50,33 @@ function clip(text, limit) {
         return chars.join('');
     return `${chars.slice(0, limit).join('')}…`;
 }
-function clipHeadTail(text, headLimit, tailLimit) {
-    const chars = Array.from((text ?? '').trim());
-    if (chars.length <= headLimit + tailLimit)
-        return chars.join('');
-    return `${chars.slice(0, headLimit).join('')}…\n…${chars.slice(-tailLimit).join('')}`;
-}
-function isNextStepHeading(line) {
-    return NEXT_STEP_HEADING_RE.test(line.trim());
-}
-function isNextStepLeadIn(line) {
-    const trimmed = line.trim();
-    if (isNextStepHeading(trimmed))
-        return true;
-    return (Array.from(trimmed).length <= NEXT_STEP_LEAD_IN_MAX_CHARS &&
-        NEXT_STEP_LEAD_IN_RE.test(trimmed));
-}
-function isMarkdownHeading(line) {
-    return /^\s*#{1,6}\s+\S/.test(line);
+function lastParagraph(text) {
+    const trimmed = (text ?? '').trim();
+    if (!trimmed)
+        return '';
+    const parts = trimmed.split(/\n\s*\n/);
+    return (parts[parts.length - 1] ?? '').trim();
 }
-/** 列表项正文；不是列表项返回 null。 */
-function listItemBody(line) {
-    const matched = line.trim().match(LIST_ITEM_RE);
-    return matched ? matched[1].trim() : null;
+/**
+ * 建议芯片的判断来源：有 `[next_steps]` 用最后一段标签正文，否则用回复最后一段。
+ */
+export function extractNextStepsSource(assistantText) {
+    const text = assistantText ?? '';
+    const matches = [...text.matchAll(new RegExp(NEXT_STEPS_BLOCK_RE.source, 'gi'))];
+    if (matches.length > 0) {
+        return (matches[matches.length - 1][1] ?? '').trim();
+    }
+    return lastParagraph(text);
 }
 function isListItem(line) {
-    return listItemBody(line) !== null;
+    return LIST_ITEM_RE.test(line.trim());
 }
-function hasScriptInvocation(text) {
-    return (/(?:^|\s)[&|]\s+/.test(text) ||
-        /\.(?:ps1|py|js|mjs|sh|bat|cmd)\b/i.test(text) ||
-        /\{scripts\}/i.test(text) ||
-        /(?:^|[\s`])(?:powershell|pwsh)\b/i.test(text) ||
-        /[A-Za-z]:\\/.test(text) ||
-        /[/\\]skills[/\\]/.test(text));
-}
-/** 去掉脚本调用、绝对路径，留下用户能点的短标题。 */
-export function stripSkillInvocation(raw) {
+/** 单条建议清洗：去编号/引号、压空白、截断。不合格返回空串。 */
+export function cleanSuggestedReply(raw) {
     let text = (raw ?? '').trim();
     text = text.replace(/`([^`]+)`/g, '$1');
     text = text.replace(/\s+[&|]\s+.+$/s, '');
     text = text.replace(/\s+[A-Za-z]:\\[^\s].*$/, '');
-    text = text.replace(/\s+(?:powershell(?:\.exe)?|pwsh)\b.*$/i, '');
-    text = text.replace(/\s+\{scripts\}.*$/i, '');
-    return text.trim();
-}
-/** 单条建议清洗：去编号/引号、压空白、截断。不合格返回空串。 */
-export function cleanSuggestedReply(raw) {
-    let text = stripSkillInvocation(raw ?? '');
     text = text.replace(/^[\s"'“”‘’「」『』《》【】]+|[\s"'“”‘’「」『』《》【】。.！!?？，,；;:：]+$/g, '');
     text = text.replace(/^(?:\d+[\.\)、]|[-*•])\s*/, '');
     text = text.replace(/\s+/g, ' ').trim();
@@ -116,10 +88,10 @@ export function cleanSuggestedReply(raw) {
     }
     return text;
 }
-function uniqueSuggestions(candidates, extras = []) {
+function uniqueSuggestions(candidates) {
     const out = [];
     const seen = new Set();
-    for (const raw of [...candidates, ...extras]) {
+    for (const raw of candidates) {
         const cleaned = cleanSuggestedReply(raw);
         if (!cleaned || seen.has(cleaned))
             continue;
@@ -130,147 +102,37 @@ function uniqueSuggestions(candidates, extras = []) {
     }
     return out;
 }
-function collectListAfter(lines, start) {
-    const items = [];
-    for (let i = start; i < lines.length; i += 1) {
-        const trimmed = lines[i].trim();
-        // 列表项之间常有空行，空行不终止收集。
-        if (!trimmed)
-            continue;
-        if (isMarkdownHeading(trimmed) || isNextStepHeading(trimmed))
-            break;
-        const body = listItemBody(trimmed);
-        if (body === null) {
-            if (items.length > 0)
-                break;
-            continue;
-        }
-        const title = stripSkillInvocation(body);
-        if (title)
-            items.push(title);
-    }
-    return items;
-}
-/**
- * 从技能正文抽出「下一步 / 后续 / Next steps」节里的列表项。
- * 兼容用户自建技能：标题不固定，脚本调用行只保留标题。
- */
-export function extractSkillNextSteps(content) {
-    const lines = (content ?? '').split(/\r?\n/);
-    const collected = [];
-    for (let i = 0; i < lines.length; i += 1) {
-        if (!isNextStepLeadIn(lines[i]))
-            continue;
-        collected.push(...collectListAfter(lines, i + 1));
-    }
-    return uniqueSuggestions(collected);
-}
-function extractHeadingNextSteps(text) {
-    const lines = (text ?? '').split(/\r?\n/);
-    let lastLeadIn = -1;
-    for (let i = 0; i < lines.length; i += 1) {
-        if (isNextStepLeadIn(lines[i]))
-            lastLeadIn = i;
-    }
-    if (lastLeadIn < 0)
-        return [];
-    return uniqueSuggestions(collectListAfter(lines, lastLeadIn + 1));
-}
-function extractTrailingScriptedList(text) {
-    const lines = (text ?? '').split(/\r?\n/);
-    let best = [];
-    let i = 0;
-    while (i < lines.length) {
-        if (!isListItem(lines[i])) {
-            i += 1;
-            continue;
-        }
-        const rawItems = [];
-        const titles = [];
-        while (i < lines.length) {
-            const trimmed = lines[i].trim();
-            if (!trimmed) {
-                i += 1;
-                continue;
-            }
-            const body = listItemBody(trimmed);
-            if (body === null)
-                break;
-            rawItems.push(body);
-            const title = stripSkillInvocation(body);
-            if (title)
-                titles.push(title);
-            i += 1;
-        }
-        if (titles.length >= 2 && rawItems.some((item) => hasScriptInvocation(item))) {
-            best = titles;
-        }
+function sliceJsonArray(raw) {
+    const trimmed = (raw ?? '').trim();
+    if (!trimmed)
+        return undefined;
+    const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    const candidate = (fenced?.[1] ?? trimmed).trim();
+    const start = candidate.indexOf('[');
+    const end = candidate.lastIndexOf(']');
+    if (start < 0 || end <= start)
+        return undefined;
+    try {
+        return JSON.parse(candidate.slice(start, end + 1));
     }
-    return uniqueSuggestions(best);
-}
-/**
- * 从助手回复抽出已列出的下一步。先看「下一步」类标题，再看末尾带脚本调用的编号列表。
- */
-export function extractListedNextSteps(text) {
-    const fromHeading = extractHeadingNextSteps(text);
-    if (fromHeading.length > 0)
-        return fromHeading;
-    return extractTrailingScriptedList(text);
-}
-function skillTitle(content) {
-    const first = (content.split(/\r?\n/, 1)[0] ?? '').trim();
-    const matched = first.match(/^#{1,6}\s+(.*)$/);
-    return matched ? matched[1].trim() : '';
-}
-/**
- * 各技能「下一步」节的合并结果，本轮点到名的技能排在前面。用户可能装了很多
- * 技能，与本轮无关的后续不该把相关的那几条挤出 {@link SUGGESTED_REPLY_MAX}。
- */
-function extractFromSkillContents(skillContents, turnText = '') {
-    if (!skillContents || skillContents.length === 0)
-        return [];
-    const ranked = skillContents
-        .map((content, index) => {
-        const title = skillTitle(content);
-        return { content, index, mentioned: title.length >= 2 && turnText.includes(title) };
-    })
-        .sort((a, b) => Number(b.mentioned) - Number(a.mentioned) || a.index - b.index);
-    const collected = [];
-    for (const entry of ranked) {
-        collected.push(...extractSkillNextSteps(entry.content));
+    catch {
+        return undefined;
     }
-    return uniqueSuggestions(collected);
-}
-/** 本轮可用的下一步：助手回复里已列出的，加上用户技能写明的。 */
-function collectNextSteps(userText, assistantText, skillContents) {
-    return uniqueSuggestions([
-        ...extractListedNextSteps(assistantText),
-        ...extractFromSkillContents(skillContents, `${userText}\n${assistantText}`),
-    ]);
 }
 /**
  * 从模型原文抽出建议。接受 JSON 数组、markdown 代码块、或编号/项目列表。
  * 最多 {@link SUGGESTED_REPLY_MAX} 条。
  */
 export function parseSuggestedReplies(raw) {
+    const parsed = sliceJsonArray(raw);
+    if (Array.isArray(parsed)) {
+        return uniqueSuggestions(parsed.filter((item) => typeof item === 'string'));
+    }
     const trimmed = (raw ?? '').trim();
     if (!trimmed)
         return [];
     const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
     const candidate = (fenced?.[1] ?? trimmed).trim();
-    const start = candidate.indexOf('[');
-    const end = candidate.lastIndexOf(']');
-    if (start >= 0 && end > start) {
-        try {
-            const parsed = JSON.parse(candidate.slice(start, end + 1));
-            if (Array.isArray(parsed)) {
-                return uniqueSuggestions(parsed.filter((item) => typeof item === 'string'));
-            }
-        }
-        catch {
-            // 落到分行解析。
-        }
-    }
     const lines = candidate
         .split(/\r?\n/)
         .map((line) => line.trim())
@@ -278,106 +140,40 @@ export function parseSuggestedReplies(raw) {
     const listLines = lines.filter((line) => isListItem(line));
     return uniqueSuggestions(listLines.length > 0 ? listLines : lines);
 }
-const PPT_FALLBACK = ['调整封面标题和配色', '把某一页内容写得更具体', '再加一页项目案例'];
-const PLAN_FALLBACK = ['按这个计划开始执行', '先改第 2 步再执行', '把计划写得更细一点'];
-const CODE_FALLBACK = ['解释这段实现的思路', '帮我补上测试', '再优化一下可读性'];
-const GENERIC_FALLBACK = ['继续完善这份结果', '换一种呈现方式', '告诉我下一步怎么做'];
-const PPT_OFFER_FALLBACK = ['调整幻灯片的内容和文案', '调整配色和版式', '再加一页补充材料'];
-/** 没有下一步可用时的句子：PPT / 计划 / 代码走专用三条，其它走通用三条。 */
-function heuristicSuggestions(userText, assistantText) {
-    const blob = `${userText}\n${assistantText}`;
-    if (/\.pptx\b|幻灯片|演示文稿|\bppt\b/i.test(blob)) { // shell-neutral:allow — Office 扩展名 'ppt'/'.pptx'，不是产品品牌
-        if (/修改内容|调整样式/.test(assistantText)) {
-            return uniqueSuggestions(PPT_OFFER_FALLBACK);
-        }
-        return uniqueSuggestions(PPT_FALLBACK);
-    }
-    if (/标准工作流程|待办清单|\bTODO\b|先制定计划/.test(blob) || /^\s*计划已/.test(assistantText)) {
-        return uniqueSuggestions(PLAN_FALLBACK);
-    }
-    if (/```|单元测试|函数实现|补测试/.test(blob)) {
-        return uniqueSuggestions(CODE_FALLBACK);
-    }
-    return uniqueSuggestions(GENERIC_FALLBACK);
-}
-/**
- * 不调模型的建议。技能或回复里已有下一步时原样采用（条数不固定），
- * 否则回落到启发式句子。
- */
-export function fallbackSuggestedReplies(userText, assistantText, opts = {}) {
-    const extracted = collectNextSteps(userText, assistantText, opts.skillContents);
-    if (extracted.length > 0)
-        return extracted;
-    return heuristicSuggestions(userText, assistantText);
-}
 /**
- * 提示词里「用户技能中的下一步」一节。只收真的写了下一步的技能——
- * 把其余技能的正文片段塞进来只会稀释上下文，且与小节标题不符。
- */
-function buildSkillExcerpt(skillContents) {
-    if (!skillContents || skillContents.length === 0)
-        return '';
-    const parts = [];
-    let used = 0;
-    for (const content of skillContents) {
-        const steps = extractSkillNextSteps(content);
-        if (steps.length === 0)
-            continue;
-        const title = skillTitle(content);
-        const body = steps.map((step, index) => `${index + 1}. ${step}`).join('\n');
-        const chunk = title ? `【${title}】\n${body}` : body;
-        const next = used + chunk.length;
-        if (next > SKILL_EXCERPT_LIMIT && parts.length > 0)
-            break;
-        parts.push(chunk);
-        used = next;
-    }
-    return parts.join('\n\n');
-}
-/**
- * 生成本轮追问建议。永不抛错；有技能/回复下一步时按实际条数返回。
+ * 生成本轮追问建议。永不抛错；没有下一步来源或模型判定没有下一步时返回空数组。
  */
 export async function generateSuggestedReplies(userText, assistantText, opts = {}) {
-    const extracted = collectNextSteps(userText, assistantText, opts.skillContents);
+    const source = extractNextStepsSource(assistantText);
     const user = clip(userText, USER_TEXT_LIMIT);
-    const assistant = clipHeadTail(assistantText, ASSISTANT_HEAD_LIMIT, ASSISTANT_TAIL_LIMIT);
-    const skillExcerpt = buildSkillExcerpt(opts.skillContents);
-    if (!user && !assistant && extracted.length === 0) {
-        return { suggestions: heuristicSuggestions(userText, assistantText), usedFallback: true };
+    const sourceClip = clip(source, SOURCE_LIMIT);
+    if (!sourceClip) {
+        return { suggestions: [], usedFallback: false };
     }
     const perAttemptTimeoutMs = opts.perAttemptTimeoutMs ?? 12_000;
     try {
-        const skillBlock = skillExcerpt
-            ? `\n\n用户技能中的下一步：\n${skillExcerpt}`
-            : '';
-        const extractedBlock = extracted.length > 0
-            ? `\n\n已从回复或技能抽出的候选（请改写成用户口吻，保留这些动作，不要压成 3 条）：\n${extracted.map((item, index) => `${index + 1}. ${item}`).join('\n')}`
-            : '';
         const result = await withTimeout(llmService.generate({
             messages: [
                 { role: 'system', content: SYSTEM_PROMPT },
                 {
                     role: 'user',
-                    content: `用户请求：\n${user || '（空）'}\n\n助手回复：\n${assistant || '（空）'}${skillBlock}${extractedBlock}`,
+                    content: `用户请求：\n${user || '（空）'}\n\n下一步来源：\n${sourceClip}`,
                 },
             ],
-            temperature: 0.6,
+            temperature: 0.4,
         }), perAttemptTimeoutMs, 'ai-suggestions');
-        const parsed = parseSuggestedReplies(result.content ?? '');
+        const raw = result.content ?? '';
+        const parsed = parseSuggestedReplies(raw);
         if (parsed.length > 0) {
-            const suggestions = extracted.length > parsed.length
-                ? uniqueSuggestions(parsed, extracted)
-                : uniqueSuggestions(parsed);
-            if (suggestions.length > 0) {
-                return { suggestions, usedFallback: false };
-            }
+            return { suggestions: parsed, usedFallback: false };
         }
+        if (Array.isArray(sliceJsonArray(raw))) {
+            return { suggestions: [], usedFallback: false };
+        }
+        return { suggestions: [], usedFallback: true };
     }
     catch (err) {
-        console.warn('[ai-suggestions] LLM 追问建议失败，用启发式兜底', err);
-    }
-    if (extracted.length > 0) {
-        return { suggestions: extracted, usedFallback: false };
+        console.warn('[ai-suggestions] LLM 追问建议失败，不展示建议', err);
+        return { suggestions: [], usedFallback: true };
     }
-    return { suggestions: heuristicSuggestions(userText, assistantText), usedFallback: true };
 }

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

@@ -174,13 +174,11 @@ export declare class LocalBackendRouter {
      */
     private handleCoreLoopTurn;
     /**
-     * 回合结束后生成下一轮用户输入建议。先同步推启发式兜底（芯片立刻出现），
-     * 再读用户/工作区技能正文，fire-and-forget 跑 LLM，成功则替换。
+     * 回合结束后生成下一轮用户输入建议。只走一次 LLM 判断
+     *（来源：`[next_steps]` 或最后一段），只广播一次最终结果。
      * 走 broadcast 而不是 SSE：`[DONE]` 之后渲染端已经不再监听这条流。
      */
     private runSuggestedRepliesInBackground;
-    /** 用户/工作区技能正文，供追问建议抽出「下一步」。内置技能不参与。 */
-    private loadUserSkillSuggestionTexts;
     private publishSuggestedReplies;
     /**
      * 标准"匿名事件" SSE：不带 event 行，前端 SSEParser 会落到默认 onMessage 分支，

package/dist/local-backend/router.js

@@ -9,7 +9,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 import { buildWorldState, getActiveCoreLoopStreamId, streamCoreLoopTurn, } from './coreloop-stream.js';
 import { driveWithAutoContinue, resolveAutoContinueMax, } from './auto-continue-helper.js';
 import { builtinSubagentParam } from './subagent-profiles.js';
-import { appendTimelineDelta, syncTimelineTools, } from './turn-timeline.js';
+import { appendTimelineDelta, freezeTimelineReasoning, sealLastTimelineBlock, syncTimelineTools, } from './turn-timeline.js';
 import { turnDurationMs } from './turn-duration.js';
 import { DEFAULT_SYSTEM_PROMPT, telemetryEnabled } from '../storage/index.js';
 import { isSkillPinned, isToolAllowed, mergeAgentCapabilities, normalizeToolPolicy, resolveSkillExcludes, } from './agent-capability.js';
@@ -27,7 +27,7 @@ import { parseUserMessageTriggers } from './message-triggers.js';
 import { findSkill, loadSkills, classifySkillOrigin, listSkillRoots } from './skill-loader.js';
 import { installSkillFromDirectory } from './skill-install.js';
 import { generateChatTitle } from './ai-title.js';
-import { fallbackSuggestedReplies, generateSuggestedReplies, } from './ai-suggestions.js';
+import { generateSuggestedReplies } from './ai-suggestions.js';
 import { detectDeferredExecution } from './deferred-detector.js';
 import { formatHistoryForSummary, truncateMiddle, } from './context-compactor.js';
 import { planRegenerateTruncate, resolveRegenerateContext, resolveRegenerateForkOrdinal, } from './regenerate-helper.js';
@@ -124,6 +124,11 @@ function buildLocalApiUser() {
 }
 const LOCAL_USER = LOCAL_USER_BASE;
 const LOCAL_AGENT_ID = 'local-agent';
+function isRoundBoundaryHook(notice) {
+    if (notice?.kind !== 'hook_action')
+        return false;
+    return notice.action === 'retry' || notice.action === 'narrate';
+}
 function buildLocalAgent() {
     const now = new Date().toISOString();
     return {
@@ -3003,6 +3008,17 @@ export class LocalBackendRouter {
                             budget: { kind: budgetKind },
                             message: budgetKind ? `budget_exhausted: ${budgetKind}` : 'budget_exhausted',
                         }));
+                        return;
+                    }
+                    // 轮次边界：封住当前思考/文本段，避免下一轮 reasoning delta
+                    // 拼进上一段，把中间的工具结果挤没。
+                    if (kind === 'round_end' || isRoundBoundaryHook(notice)) {
+                        sealLastTimelineBlock(timeline);
+                        emit(this.sseData({
+                            type: 'completion',
+                            status: 'executing',
+                            ...(typeof notice?.round === 'number' ? { round: notice.round } : {}),
+                        }));
                     }
                 },
                 onChildEvent: (event) => {
@@ -3053,6 +3069,8 @@ export class LocalBackendRouter {
                     }
                 },
                 onContinuation: (pass, max) => {
+                    sealLastTimelineBlock(timeline);
+                    emit(this.sseData({ type: 'completion', status: 'executing' }));
                     console.log('[local-backend] coreloop budget exhausted — auto-continuing', {
                         chatId,
                         pass,
@@ -3104,6 +3122,7 @@ export class LocalBackendRouter {
         catch (turnFilesErr) {
             console.warn('[local-backend] collect turn files failed', turnFilesErr);
         }
+        freezeTimelineReasoning(timeline);
         const assistant = await this.store.addMessage(chatId, 'assistant', assistantText, JSON.stringify({
             completionStatus,
             completionReason,
@@ -3205,8 +3224,8 @@ export class LocalBackendRouter {
         return { status: 200 };
     }
     /**
-     * 回合结束后生成下一轮用户输入建议。先同步推启发式兜底（芯片立刻出现），
-     * 再读用户/工作区技能正文，fire-and-forget 跑 LLM，成功则替换。
+     * 回合结束后生成下一轮用户输入建议。只走一次 LLM 判断
+     *（来源：`[next_steps]` 或最后一段），只广播一次最终结果。
      * 走 broadcast 而不是 SSE：`[DONE]` 之后渲染端已经不再监听这条流。
      */
     runSuggestedRepliesInBackground(args) {
@@ -3215,27 +3234,11 @@ export class LocalBackendRouter {
             return;
         if (!assistantText.trim())
             return;
-        const fallback = fallbackSuggestedReplies(userText, assistantText);
-        this.publishSuggestedReplies(chatId, messageId, fallback);
         void (async () => {
             try {
-                const skillContents = await this.loadUserSkillSuggestionTexts();
-                const enriched = fallbackSuggestedReplies(userText, assistantText, { skillContents });
-                if (enriched.length !== fallback.length ||
-                    enriched.some((item, i) => item !== fallback[i])) {
-                    this.publishSuggestedReplies(chatId, messageId, enriched);
-                }
                 const result = await generateSuggestedReplies(userText, assistantText, {
                     perAttemptTimeoutMs: 60_000,
-                    skillContents,
                 });
-                if (result.usedFallback)
-                    return;
-                const baseline = enriched.length > 0 ? enriched : fallback;
-                const same = result.suggestions.length === baseline.length &&
-                    result.suggestions.every((item, i) => item === baseline[i]);
-                if (same)
-                    return;
                 this.publishSuggestedReplies(chatId, messageId, result.suggestions);
             }
             catch (err) {
@@ -3243,26 +3246,6 @@ export class LocalBackendRouter {
             }
         })();
     }
-    /** 用户/工作区技能正文，供追问建议抽出「下一步」。内置技能不参与。 */
-    async loadUserSkillSuggestionTexts() {
-        try {
-            const modules = await loadSkills({ ignoreConditions: true });
-            return modules
-                .filter((module) => classifySkillOrigin(module.skillsDir) !== 'builtin')
-                .map((module) => {
-                const title = (module.displayName || module.name || module.dirName || '').trim();
-                const body = (module.content ?? '').trim();
-                if (!body)
-                    return '';
-                return title ? `# ${title}\n${body}` : body;
-            })
-                .filter(Boolean);
-        }
-        catch (err) {
-            console.warn('[local-backend] suggested-replies skill load failed', err);
-            return [];
-        }
-    }
     async publishSuggestedReplies(chatId, messageId, suggestions) {
         if (suggestions.length === 0)
             return;

package/dist/local-backend/skills/00-identity/SKILL.md

@@ -22,6 +22,17 @@ tags: [identity, base]
 - 工具失败或无权限时，把错误如实告诉用户，并建议下一步动作。
 - 回复保持简洁；超过 6-8 行的长内容用 markdown 列表或代码块组织。
 
+## 下一步建议
+
+回合结束且用户还能接着做时，把建议写在回复最后一段，并用标签包起来（标签本身不会显示，只显示里面的内容）：
+
+[next_steps]
+- 调整封面配色
+- 把第 2 页写具体
+[/next_steps]
+
+只写真实的下一步。本轮已完成的汇报（文件位置、页数、内容结构等）不要放进标签。没有下一步就不要写这个标签。
+
 ## 结构化提问（ask_user）使用规范
 
 当你需要向用户收集结构化信息（提供选项让用户选择）时，使用 `ask_user` 工具，并遵守：

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

@@ -5,12 +5,22 @@
 export type PersistedTurnBlock = {
     type: 'reasoning';
     content: string;
+    sealed?: boolean;
+    startedAtMs?: number;
+    durationMs?: number;
 } | {
     type: 'text';
     content: string;
+    sealed?: boolean;
 } | {
     type: 'tools';
     actions: Array<Record<string, unknown>>;
 };
-export declare function appendTimelineDelta(blocks: PersistedTurnBlock[], type: 'text' | 'reasoning', delta: string): void;
-export declare function syncTimelineTools(blocks: PersistedTurnBlock[], actions: Array<Record<string, unknown>>): void;
+export declare function appendTimelineDelta(blocks: PersistedTurnBlock[], type: 'text' | 'reasoning', delta: string, now?: number): void;
+/**
+ * Close the current reasoning/text segment so the next same-kind delta
+ * starts a new block. Mirrors apps/web `sealLastBlock`.
+ */
+export declare function sealLastTimelineBlock(blocks: PersistedTurnBlock[], now?: number): void;
+export declare function freezeTimelineReasoning(blocks: PersistedTurnBlock[], now?: number): void;
+export declare function syncTimelineTools(blocks: PersistedTurnBlock[], actions: Array<Record<string, unknown>>, now?: number): void;

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

@@ -2,17 +2,44 @@
  * Call-order display blocks persisted on assistant message metadata.
  * Keep this JSON compatible with apps/web `turn-timeline.ts`.
  */
-export function appendTimelineDelta(blocks, type, delta) {
+function freezeOpenReasoning(blocks, now = Date.now()) {
+    const last = blocks[blocks.length - 1];
+    if (!last || last.type !== 'reasoning' || last.durationMs != null)
+        return;
+    if (last.startedAtMs == null)
+        return;
+    last.durationMs = Math.max(0, now - last.startedAtMs);
+}
+export function appendTimelineDelta(blocks, type, delta, now = Date.now()) {
     if (!delta)
         return;
     const last = blocks[blocks.length - 1];
-    if (last && last.type === type) {
+    if (last && last.type === type && !last.sealed) {
         last.content += delta;
         return;
     }
+    freezeOpenReasoning(blocks, now);
+    if (type === 'reasoning') {
+        blocks.push({ type, content: delta, startedAtMs: now });
+        return;
+    }
     blocks.push({ type, content: delta });
 }
-export function syncTimelineTools(blocks, actions) {
+/**
+ * Close the current reasoning/text segment so the next same-kind delta
+ * starts a new block. Mirrors apps/web `sealLastBlock`.
+ */
+export function sealLastTimelineBlock(blocks, now = Date.now()) {
+    const last = blocks[blocks.length - 1];
+    if (!last || last.type === 'tools' || last.sealed)
+        return;
+    freezeOpenReasoning(blocks, now);
+    last.sealed = true;
+}
+export function freezeTimelineReasoning(blocks, now = Date.now()) {
+    freezeOpenReasoning(blocks, now);
+}
+export function syncTimelineTools(blocks, actions, now = Date.now()) {
     let placed = 0;
     for (const block of blocks) {
         if (block.type === 'tools')
@@ -37,6 +64,7 @@ export function syncTimelineTools(blocks, actions) {
         last.actions.push(...added);
     }
     else {
+        freezeOpenReasoning(blocks, now);
         blocks.push({ type: 'tools', actions: added });
     }
 }

package/dist/sidecar/supervisor.d.ts

@@ -11,6 +11,8 @@
  */
 import { EventEmitter } from 'node:events';
 import type { SidecarApplyEditsResult, SidecarChatStreamHandlers, SidecarChatStreamRequest, SidecarHealthSnapshot, SidecarMethodOptions, SidecarModelCatalog, SidecarReverseHandler, SidecarSandboxPosture, SidecarSessionBranches, SidecarSessionForkOutcome, SidecarSessionMessages, SidecarSessionTree, SidecarSkillModule, SidecarStartOptions, SidecarToolResult } from './types.js';
+export declare const RUST_SIDECAR_ENV = "STEERABLE_RUST_SIDECAR";
+export declare const RUST_SIDECAR_BIN_ENV = "STEERABLE_RUST_SIDECAR_BIN";
 /**
  * Tool names carried by a `tool.list` reply.
  *
@@ -216,3 +218,9 @@ export declare class SidecarSupervisor extends EventEmitter {
  * launcher (W1.3.3) spawns the same interpreter the sidecar uses.
  */
 export declare function resolveSidecarPython(pythonExecutable?: string): string;
+export declare function rustSidecarEnabled(): boolean;
+/**
+ * Resolve the optional Rust sidecar binary. Missing binary with the flag
+ * on is a silent fallback to Python (`python -m steerable_sidecar`).
+ */
+export declare function resolveRustSidecarBin(explicit?: string): string | undefined;

package/dist/sidecar/supervisor.js

@@ -25,6 +25,8 @@ const READY_PREFIX = '__SIDECAR_READY__:';
 const DEFAULT_BOOT_TIMEOUT_MS = 15_000;
 const DEFAULT_HEALTH_INTERVAL_MS = 5_000;
 const DEFAULT_RESTART_AFTER_FAILED_PINGS = 3;
+export const RUST_SIDECAR_ENV = 'STEERABLE_RUST_SIDECAR';
+export const RUST_SIDECAR_BIN_ENV = 'STEERABLE_RUST_SIDECAR_BIN';
 // Only /usr/bin/sandbox-exec is trusted — a PATH-relative lookup could
 // resolve to an attacker-planted binary (codex's rule).
 const SEATBELT_EXECUTABLE = '/usr/bin/sandbox-exec';
@@ -381,10 +383,19 @@ export class SidecarSupervisor extends EventEmitter {
     // Internal: boot
     // ------------------------------------------------------------------
     async boot() {
-        const py = this.resolvePythonBinary();
-        const entry = this.options.entryModule ?? 'steerable_sidecar';
-        const args = ['-m', entry, ...(this.options.args ?? [])];
-        const spawnPlan = await this.resolveSandboxedSpawn(py, args);
+        const rustBin = rustSidecarEnabled()
+            ? resolveRustSidecarBin(this.options.rustSidecarBin)
+            : undefined;
+        let spawnPlan;
+        if (rustBin) {
+            spawnPlan = await this.resolveSandboxedSpawn(rustBin, this.options.args ?? []);
+        }
+        else {
+            const py = this.resolvePythonBinary();
+            const entry = this.options.entryModule ?? 'steerable_sidecar';
+            const args = ['-m', entry, ...(this.options.args ?? [])];
+            spawnPlan = await this.resolveSandboxedSpawn(py, args);
+        }
         const child = spawn(spawnPlan.command, spawnPlan.args, {
             cwd: this.options.cwd,
             env: { ...process.env, ...this.options.env, ...spawnPlan.env },
@@ -416,8 +427,8 @@ export class SidecarSupervisor extends EventEmitter {
      * (`sandbox: false` / `STEERABLE_SIDECAR_SANDBOX=0`) is the only
      * unconfined path. Every exit records `sandboxPosture`.
      */
-    async resolveSandboxedSpawn(py, args) {
-        const plain = { command: py, args };
+    async resolveSandboxedSpawn(command, args) {
+        const plain = { command, args };
         const enabled = this.options.sandbox ?? process.env.STEERABLE_SIDECAR_SANDBOX !== '0';
         if (!enabled) {
             this.sandboxPosture = {
@@ -446,16 +457,16 @@ export class SidecarSupervisor extends EventEmitter {
                 .filter(Boolean);
         const webEgress = Boolean(this.options.sandboxWebEgress) && allowedHosts.length > 0;
         // 3.1b: egress-proxy 模式下 web_fetch 的 SSRF 预检在沙箱内解析 DNS，
-        // 只放行解析器 socket（无 IP 可达性）；webEgress 已含解析器，互斥。
+        // 但真正的出口走代理。Seatbelt 只放行 resolver socket，不放行 *:80/443。
         const allowResolver = Boolean(this.options.sandboxAllowResolver) && allowedHosts.length > 0 && !webEgress;
         if (process.platform === 'darwin') {
-            return this.wrapSeatbelt(py, args, writableRoots, allowedHosts, webEgress, allowResolver);
+            return this.wrapSeatbelt(command, args, writableRoots, allowedHosts, webEgress, allowResolver);
         }
         if (process.platform === 'linux') {
-            return this.wrapLinux(py, args, writableRoots);
+            return this.wrapLinux(command, args, writableRoots);
         }
         if (process.platform === 'win32') {
-            return this.wrapWindows(py, args, writableRoots);
+            return this.wrapWindows(command, args, writableRoots);
         }
         const posture = {
             backend: 'none',
@@ -470,21 +481,23 @@ export class SidecarSupervisor extends EventEmitter {
         this.options.onLogLine?.(message);
         throw new SidecarSandboxUnavailableError(message, posture, cause);
     }
-    async wrapSeatbelt(py, args, writableRoots, allowedHosts, webEgress, allowResolver) {
+    async wrapSeatbelt(command, args, writableRoots, allowedHosts, webEgress, allowResolver) {
         if (!existsSync(SEATBELT_EXECUTABLE)) {
             this.refuse({ backend: 'none', enforcement: 'none', reason: 'seatbelt_missing' }, 'sandbox: /usr/bin/sandbox-exec missing; refusing unsandboxed spawn');
         }
         try {
-            const profileArgs = [
-                '-m',
-                'steerable_sidecar.sandbox',
-                'profile',
+            const flags = [
                 ...writableRoots.flatMap((root) => ['--writable-root', root]),
                 ...allowedHosts.flatMap((h) => ['--allow-host', h]),
                 ...(webEgress ? ['--allow-web-egress'] : []),
                 ...(allowResolver ? ['--allow-resolver'] : []),
             ];
-            const { stdout } = await execFileAsync(py, profileArgs, { timeout: 10_000 });
+            const rustBin = rustSidecarEnabled()
+                ? resolveRustSidecarBin(this.options.rustSidecarBin)
+                : undefined;
+            const { stdout } = rustBin
+                ? await execFileAsync(rustBin, ['sandbox', 'profile', ...flags], { timeout: 10_000 })
+                : await execFileAsync(command, ['-m', 'steerable_sidecar.sandbox', 'profile', ...flags], { timeout: 10_000 });
             const profile = stdout.trim();
             if (!profile.includes('(deny default)')) {
                 throw new Error('generated profile is not a Seatbelt policy');
@@ -497,7 +510,7 @@ export class SidecarSupervisor extends EventEmitter {
             this.sandboxPosture = { backend: 'seatbelt', enforcement: 'partial', reason: 'active' };
             return {
                 command: SEATBELT_EXECUTABLE,
-                args: ['-p', profile, py, ...args],
+                args: ['-p', profile, command, ...args],
                 env: {
                     PYTHONDONTWRITEBYTECODE: '1',
                     // macOS denies a nested sandbox_apply once the outer profile allows
@@ -516,7 +529,7 @@ export class SidecarSupervisor extends EventEmitter {
             this.refuse({ backend: 'none', enforcement: 'none', reason: 'profile_failed' }, `sandbox: profile generation failed; refusing unsandboxed spawn: ${String(err)}`, err);
         }
     }
-    async wrapLinux(py, args, writableRoots) {
+    async wrapLinux(command, args, writableRoots) {
         // 3.1c：框架的 linux-wrap 只接受 --writable-root / --no-network——
         // bwrap 的 allowed_hosts 仅是接口兼容（不强制），Landlock 根本没有
         // per-host egress。所以 Linux 的按主机管控不在 layer-1：egress-proxy
@@ -524,17 +537,29 @@ export class SidecarSupervisor extends EventEmitter {
         // 都透传环境）+ sidecar 应用层域名名单强制，网络命名空间保持共享。
         // 这里如实记录，不假装接上了实际不强制的参数。
         const egressViaProxy = this.options.env?.STEERABLE_EGRESS_CONFINED === '1';
-        const wrapArgs = [
-            '-m',
-            'steerable_sidecar.sandbox',
-            'linux-wrap',
-            ...writableRoots.flatMap((root) => ['--writable-root', root]),
-            '--',
-            py,
-            ...args,
-        ];
+        const rustBin = rustSidecarEnabled()
+            ? resolveRustSidecarBin(this.options.rustSidecarBin)
+            : undefined;
+        const wrapArgs = rustBin
+            ? [
+                'sandbox',
+                'linux-wrap',
+                ...writableRoots.flatMap((root) => ['--writable-root', root]),
+                '--',
+                command,
+                ...args,
+            ]
+            : [
+                '-m',
+                'steerable_sidecar.sandbox',
+                'linux-wrap',
+                ...writableRoots.flatMap((root) => ['--writable-root', root]),
+                '--',
+                command,
+                ...args,
+            ];
         try {
-            const { stdout } = await execFileAsync(py, wrapArgs, { timeout: 15_000 });
+            const { stdout } = await execFileAsync(rustBin ?? command, wrapArgs, { timeout: 15_000 });
             const plan = JSON.parse(stdout.trim());
             if (!Array.isArray(plan.argv) || plan.argv.length < 1 || typeof plan.argv[0] !== 'string') {
                 throw new Error('linux-wrap did not return an argv');
@@ -562,7 +587,7 @@ export class SidecarSupervisor extends EventEmitter {
             this.refuse({ backend: 'none', enforcement: 'none', reason: 'wrap_failed' }, `sandbox: Linux process wrap failed; refusing unsandboxed spawn: ${String(err)}`, err);
         }
     }
-    wrapWindows(py, args, writableRoots) {
+    wrapWindows(command, args, writableRoots) {
         const helper = resolveWinSpawnHelperPath();
         if (!helper) {
             this.refuse({ backend: 'none', enforcement: 'none', reason: 'helper_missing' }, 'sandbox: win-spawn-helper.exe not found; refusing unsandboxed sidecar spawn');
@@ -590,7 +615,7 @@ export class SidecarSupervisor extends EventEmitter {
                 steerableDir,
                 ...extraRoots.flatMap((root) => ['--writable-root', root]),
                 '--',
-                py,
+                command,
                 ...args,
             ],
             env: {
@@ -930,3 +955,36 @@ export function resolveSidecarPython(pythonExecutable) {
     // Fallback to system python (developer machines).
     return process.platform === 'win32' ? 'python' : 'python3';
 }
+function envFlag(name) {
+    const raw = (process.env[name] ?? '').trim().toLowerCase();
+    return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on';
+}
+export function rustSidecarEnabled() {
+    return envFlag(RUST_SIDECAR_ENV);
+}
+/**
+ * Resolve the optional Rust sidecar binary. Missing binary with the flag
+ * on is a silent fallback to Python (`python -m steerable_sidecar`).
+ */
+export function resolveRustSidecarBin(explicit) {
+    if (explicit) {
+        return existsSync(explicit) ? explicit : undefined;
+    }
+    const fromEnv = process.env[RUST_SIDECAR_BIN_ENV];
+    if (fromEnv) {
+        return existsSync(fromEnv) ? fromEnv : undefined;
+    }
+    const exe = process.platform === 'win32' ? 'steerable-sidecar.exe' : 'steerable-sidecar';
+    const relatives = [
+        join('..', '..', '..', '..', 'sidecar', 'rs', 'target', 'debug', exe),
+        join('..', '..', '..', '..', '..', 'sidecar', 'rs', 'target', 'debug', exe),
+        join('..', '..', '..', '..', 'sidecar', 'rs', 'target', 'release', exe),
+        join('..', '..', '..', '..', '..', 'sidecar', 'rs', 'target', 'release', exe),
+    ];
+    for (const rel of relatives) {
+        const candidate = join(__dirname, rel);
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return undefined;
+}

package/dist/sidecar/types.d.ts

@@ -21,6 +21,8 @@ export interface SidecarSandboxPosture {
 export interface SidecarStartOptions {
     /** Override the python binary; defaults to the bundled portable runtime. */
     pythonExecutable?: string;
+    /** Optional Rust sidecar binary; used when STEERABLE_RUST_SIDECAR is on. */
+    rustSidecarBin?: string;
     /** Override the entrypoint module; defaults to ``steerable_sidecar``. */
     entryModule?: string;
     /** Extra arguments appended after ``-m <entryModule>``. */
@@ -495,7 +497,7 @@ export interface SidecarStreamChunk {
             enforcement: string;
         };
     };
-    /** CoreLoop notices: soft_timeout / budget_exhausted. */
+    /** CoreLoop notices: soft_timeout / budget_exhausted / round_end / hook_action. */
     notice?: {
         kind: string;
         [key: string]: unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steerable/agent-shell",
-  "version": "0.6.26",
+  "version": "0.6.28",
   "description": "Steerable framework — product-neutral desktop/headless agent host (Tier 5). Electron main + preload + headless HTTP server (BS) sharing one storage/sidecar/tooling core; scenario packs extend it through the @steerable/pack-sdk contract and are composed at build time by the consuming product.",
   "license": "Apache-2.0",
   "homepage": "https://steerableframework.com/",
@@ -49,9 +49,9 @@
     "electron-store": "^8.1.0",
     "he": "^1.2.0",
     "node-pty": "^1.1.0",
-    "@steerable/agent-harness": "0.6.26",
-    "@steerable/agent-protocol": "0.6.26",
-    "@steerable/pack-sdk": "0.6.26"
+    "@steerable/agent-harness": "0.6.28",
+    "@steerable/pack-sdk": "0.6.28",
+    "@steerable/agent-protocol": "0.6.28"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",