@cspeach/cli 1.1.24 → 1.1.26

package/dist/one-shot.js

@@ -13,11 +13,12 @@ import { makeSessionId, saveSession } from './session/store.js';
 import { newSession } from './session/schema.js';
 import { resolveModelRole } from './models/resolve.js';
 import { loadServerModelConfig, loadCustomerModelConfig, fetchToolLoadingMode } from './models/server-config.js';
+import { prefetchRouterPrompt } from './router/router-prompt.js';
 import { createProviderForMode } from './agent/providers/factory.js';
 import { assertModeLicensed, CspeachLicenseError } from './agent/providers/license-gate.js';
 import { runTurn } from './agent/loop.js';
 import { classifyPrompt, parseShortcut, rejectUnknownSkill } from './router/classifier.js';
-import { routingFailureFromResult, routingFailureOneShotLine } from './router/routing-failure.js';
+import { routingFailureFromResult, routingFailureOneShotLine, routingFallbackFromError } from './router/routing-failure.js';
 import { startThinkingHeartbeat, ROUTING_HEARTBEAT_THRESHOLDS } from './renderer/thinking-heartbeat.js';
 import { setRenderingOverride, setHeadlessOverride, setOneShotOverride } from './renderer/tty.js';
 import { resolveRenderingMode } from './renderer/rendering-mode.js';
@@ -96,6 +97,9 @@ export async function runOneShot(prompt, opts) {
         loadCustomerModelConfig(cfg, async () => (await (await getStore()).get()) ?? '', { timeoutMs: 1500 }),
         // Task 16 (F13) — BYOK reads only the served tool_loading (signed in only).
         fetchToolLoadingMode(cfg, async () => (await (await getStore()).get()) ?? '', { timeoutMs: 1500 }),
+        // 2026-10-02 — BYOK / ai-hub route on the laptop: prefetch the signed
+        // router prompt (public manifest, no prompt data) under the same cap.
+        cfg.llm?.mode === 'byok' || cfg.llm?.mode === 'ai-hub' ? prefetchRouterPrompt({ timeoutMs: 1500 }) : Promise.resolve(),
     ]);
     // B5 (2026-06-11) — one-shot is headless by design: a single turn, no
     // REPL, often piped (CI / battery). Any stdin prompt would hang forever
@@ -224,7 +228,13 @@ export async function runOneShot(prompt, opts) {
                 console.error('No API key configured. Run `cspeach` (interactive) first to set one.');
                 return 1;
             }
-            throw err;
+            // Live fix 2026-10-02 — a classify failure (proxy HTTP 500, an
+            // unreadable body) escaped as "cspeach: unhandled error". Continue on
+            // the bundled local rules instead; the offline line below says so.
+            const fallback = routingFallbackFromError(err, body);
+            if (!fallback)
+                throw err;
+            c = fallback;
         }
         finally {
             routingBeat.stop();

package/dist/projects/detail-path.js

@@ -0,0 +1,117 @@
+// cspeach-cli/src/projects/detail-path.ts
+/**
+ * SEC (review round 2): `content.detailPath` inside a saved envelope is DATA
+ * the model can write — never a trusted path. Every reader that turns it into
+ * a file access (upgrade merge baseline hash, the register's CCA objects.json,
+ * promote's file_read hint) goes through here:
+ *
+ *   - safeDetailRel: the string must be a plain project-relative path under a
+ *     skill working folder — `.cspeach/<domain>/…` (or the legacy
+ *     `.abapforge/<domain>/…`). No absolute paths, drive letters, `..`, `:`
+ *     streams, control characters, trailing dots/spaces or device names.
+ *   - resolveDetailFile(Sync): the REAL file must sit in that working folder
+ *     under the project root (or the workspace folder) and not be a protected
+ *     path. Returns null for refused AND missing alike, so callers can give ONE
+ *     message and never act as an existence oracle.
+ */
+import * as path from 'node:path';
+import { realpathSync, statSync } from 'node:fs';
+import { CSPEACH_WORK_SUBDIRS, isDenylistedPath, isWindowsReservedName } from '../tools/_filesystem-shared.js';
+import { workspaceFolderFor } from '../lane/roots.js';
+/** Working-folder roots a detail path may start with (current, legacy). */
+const DETAIL_ROOTS = ['.cspeach', '.abapforge'];
+/**
+ * The normalised '/'-separated project-relative detail path, or null when the
+ * value is not a safe path into `<root>/<domain>/` (any domain when omitted).
+ */
+export function safeDetailRel(detailPath, domain) {
+    if (typeof detailPath !== 'string' || detailPath.length === 0 || detailPath.length > 512)
+        return null;
+    if (/[\u0000-\u001f\u007f]/.test(detailPath))
+        return null;
+    if (path.posix.isAbsolute(detailPath) || path.win32.isAbsolute(detailPath) || /^[A-Za-z]:/.test(detailPath))
+        return null;
+    const segs = detailPath.replace(/\\/g, '/').split('/');
+    while (segs[0] === '.')
+        segs.shift();
+    if (segs.length < 3)
+        return null;
+    for (const seg of segs) {
+        if (seg === '' || seg === '.' || seg === '..')
+            return null;
+        if (seg.includes(':') || /[. ]$/.test(seg) || /[<>"|?*]/.test(seg))
+            return null;
+        if (isWindowsReservedName(seg))
+            return null;
+    }
+    const rootSeg = segs[0].toLowerCase();
+    const domainSeg = segs[1].toLowerCase();
+    if (!DETAIL_ROOTS.includes(rootSeg))
+        return null;
+    if (domain ? domainSeg !== domain : !CSPEACH_WORK_SUBDIRS.includes(domainSeg))
+        return null;
+    return segs.join('/');
+}
+function realOrNull(p) {
+    try {
+        return realpathSync.native(p);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The real path of the first candidate that exists, is a regular file, stays
+ * inside `<base>/<first two segments of rel>/` after links are followed, and
+ * is not denylisted relative to `cwd`. null otherwise.
+ */
+function firstContained(cands, cwd) {
+    for (const { base, rel, keep } of cands) {
+        const realBase = realOrNull(path.resolve(base));
+        const real = realOrNull(path.join(path.resolve(base), ...rel.split('/')));
+        if (!realBase || !real)
+            continue;
+        const segs = rel.split('/');
+        const folder = path.join(realBase, ...segs.slice(0, keep));
+        const inner = path.relative(folder, real);
+        if (inner === '' || inner.startsWith('..') || path.isAbsolute(inner))
+            continue;
+        if (isDenylistedPath(real, cwd).blocked)
+            continue;
+        try {
+            if (!statSync(real).isFile())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        return real;
+    }
+    return null;
+}
+/** Sync resolution under the project root only (callers without a workspace). */
+export function resolveDetailFileSync(detailPath, domain, projectRoot) {
+    const rel = safeDetailRel(detailPath, domain);
+    if (!rel)
+        return null;
+    return firstContained([{ base: projectRoot, rel, keep: 2 }], projectRoot);
+}
+/**
+ * Resolution under the project root (cwd) and the resolved workspace folder
+ * (which may sit elsewhere: a git-root `.cspeach/`, a configured folder). For
+ * the workspace, a `.cspeach/<domain>/x` path maps to `<workspace>/<domain>/x`.
+ */
+export async function resolveDetailFile(detailPath, domain, cwd) {
+    const rel = safeDetailRel(detailPath, domain);
+    if (!rel)
+        return null;
+    const cands = [{ base: cwd, rel, keep: 2 }];
+    const segs = rel.split('/');
+    if (segs[0].toLowerCase() === '.cspeach') {
+        try {
+            cands.push({ base: await workspaceFolderFor(cwd), rel: segs.slice(1).join('/'), keep: 1 });
+        }
+        catch { /* no workspace — project root only */ }
+    }
+    return firstContained(cands, cwd);
+}

package/dist/projects/merge-cca.js

@@ -27,6 +27,7 @@
  *     file must be consulted for full coverage
  */
 import { OUTPUT_ROOT } from './output-paths.js';
+import { isWindowsReservedName } from '../tools/_filesystem-shared.js';
 /** Higher = more restrictive. Conflict resolution picks the max. */
 const RESTRICTIVENESS = {
     retire: 3,
@@ -94,6 +95,19 @@ export function scopePatternsIntersect(a, b) {
 function todayUtc() {
     return new Date().toISOString().slice(0, 10);
 }
+/** A folder/file-name slug: `^[A-Za-z0-9._-]+$`, no `..`, not `.`, no device name. */
+export function assertMergeSlug(label, value) {
+    const ok = typeof value === 'string'
+        && value.length > 0 && value.length <= 100
+        && /^[A-Za-z0-9._-]+$/.test(value)
+        && !value.includes('..') && value !== '.'
+        && !/[. ]$/.test(value)
+        && !isWindowsReservedName(value);
+    if (!ok) {
+        throw new Error(`${label} ${JSON.stringify(value)} cannot name a folder — use letters, digits, ".", "_" and "-" only `
+            + '(no "..", no device names such as CON or NUL).');
+    }
+}
 export function mergeCcaAssessments(inputs, opts = {}) {
     if (inputs.length < 2) {
         throw new Error(`cca merge requires at least 2 inputs (got ${inputs.length}) — a single assessment needs no merge`);
@@ -214,6 +228,11 @@ export function mergeCcaAssessments(inputs, opts = {}) {
     // overlap is already warned about above).
     const uncategorized = inputs.reduce((sum, inp) => sum + (inp.content.summary.uncategorized || 0), 0);
     const date = opts.mergedDate ?? todayUtc();
+    // SEC (review round 2): projectId comes from INSIDE an envelope (model-
+    // writable) and becomes a folder name under .cspeach/cca/projects/. Only a
+    // plain slug may do that — never `../`, a drive, a stream or a device name.
+    assertMergeSlug('projectId', first.content.projectId);
+    assertMergeSlug('merged date', date);
     const mergedProjectId = `${first.content.projectId}_merged_${date}`;
     const scopes = [];
     for (const inp of inputs) {

package/dist/projects/merge-upgrade.js

@@ -17,6 +17,22 @@
  *   - counts RECOMPUTED from merged rows — never trusted from inputs
  */
 import { OUTPUT_ROOT } from './output-paths.js';
+import { isWindowsReservedName } from '../tools/_filesystem-shared.js';
+/**
+ * SEC (review round 2): the merged detail FILE NAME is built from the last
+ * segment of the baseline path, which comes from inside an envelope (model-
+ * writable). On Windows `base.json:ads` would write an NTFS stream and `CON`
+ * opens the console. Keep only `[A-Za-z0-9._-]`, drop a stream suffix, never
+ * `..` or a device name; fall back to `baseline`.
+ */
+export function safeStem(baselinePath) {
+    const last = (typeof baselinePath === 'string' ? baselinePath : '').split(/[\\/]/).pop() ?? '';
+    let stem = last.split(':')[0].replace(/\.json$/i, '');
+    stem = stem.replace(/[^A-Za-z0-9._-]/g, '_').replace(/\.{2,}/g, '_').replace(/^[._-]+|[._ -]+$/g, '');
+    if (!stem || stem.length > 100 || isWindowsReservedName(stem))
+        return 'baseline';
+    return stem;
+}
 /** Higher = wins the reconciliation. */
 const STATUS_PRECEDENCE = {
     failed: 3,
@@ -124,7 +140,9 @@ export function mergeUpgradeProgress(inputs, baseline) {
     }
     const baselinePath = baseline.path ?? inputs[0].content.baselineRef.path;
     const date = baseline.mergedDate ?? todayUtc();
-    const stem = (baselinePath.split(/[\\\/]/).pop() ?? 'baseline').replace(/\.json$/i, '');
+    const stem = safeStem(baselinePath);
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(date))
+        throw new Error(`merged date ${JSON.stringify(date)} must be YYYY-MM-DD`);
     const merged = {
         detailPath: `${OUTPUT_ROOT}/upgrades/${stem}_progress_merged_${date}.json`,
         baselineRef: { path: baselinePath, sha256: baseline.sha256 },

package/dist/projects/plan-lane.js

@@ -108,6 +108,53 @@ export function checkLaneConsistency(content, rec) {
     }
     return null;
 }
+/* ── deploy is a required step of a UI lane (owner, 2026-10-02) ─────────── */
+/**
+ * A rap lane with a UI, and the `none` lane (a UI on an already published
+ * service), build an app that runs on SAP — its plan must deploy it. cap is
+ * out (the BTP deploy is not built); abap-report has no UI.
+ */
+export function laneRequiresDeploy(rec) {
+    const { backend, ui } = rec.final;
+    return (backend === 'rap' && ui !== 'none') || backend === 'none';
+}
+/** The deploy phase of a UI: ui layer, /abap-fiori-build, id `ui.deploy` (or `<app>.deploy`). */
+export function isDeployPhase(p) {
+    return p.layer === 'ui' && p.delegateTo === 'abap-fiori-build' && /(^|\.)deploy$/.test(p.id);
+}
+/** The developer's recorded reason for not deploying (phases[ui.build].ui.deployOptOut), if any. */
+export function deployOptOutOf(phases) {
+    for (const p of phases) {
+        const why = p.ui?.deployOptOut?.trim();
+        if (why)
+            return why;
+    }
+    return undefined;
+}
+/**
+ * Refuse a UI-lane plan with no deploy phase (and no recorded opt-out), or
+ * whose deploy phase does not wait for a UI build phase. Returns a plain
+ * refusal or null. Checked at save; a phase write-back may not remove it.
+ */
+export function checkRequiredDeploy(content, rec) {
+    if (!laneRequiresDeploy(rec))
+        return null;
+    const deploys = content.phases.filter(isDeployPhase);
+    if (deploys.length === 0) {
+        if (deployOptOutOf(content.phases))
+            return null;
+        return ('This lane builds an app that runs on SAP, so the plan needs a ui.deploy phase (deploy the app to the ABAP ' +
+            'repository, delegateTo abap-fiori-build, layer ui) after ui.build. If the developer does not want it deployed, ' +
+            'record their words in phases[ui.build].ui.deployOptOut. Re-run /abap-plan.');
+    }
+    const builds = new Set(content.phases.filter((p) => p.layer === 'ui' && !isDeployPhase(p)).map((p) => p.id));
+    for (const d of deploys) {
+        if (!d.entryCriteria.some((id) => builds.has(id))) {
+            return `Phase ${cardLine(d.id)} must run after ui.build — list the UI build phase in its entryCriteria. Re-run /abap-plan.`;
+        }
+    }
+    return null;
+}
 /**
  * Resume / continuation gate: read the plan's lane with its recorded sha,
  * re-validate it and check the stored phases against it. Lane-less plans pass

package/dist/projects/plan-run.js

@@ -372,6 +372,14 @@ g = getGlyphs()) {
     if (deployed?.work?.deployedUrl) {
         lines.push(`App deployed: ${deployed.work.deployedUrl}`);
     }
+    else if (phases.some((p) => p.layer === 'ui' && p.delegateTo === 'abap-fiori-build' && p.ui !== undefined)) {
+        // 2026-10-02 — deploy is a chained step of a UI plan: finishing without a
+        // deployed app is said out loud, never left to silence.
+        const optOut = phases.map((p) => p.ui?.deployOptOut?.trim()).find((w) => !!w);
+        lines.push(optOut
+            ? `${g.info} Deploy skipped by the developer: ${sanitizeControlChars(optOut)}`
+            : `${g.attention} The app was not deployed to SAP — it runs only in local preview. Deploy it with /abap-fiori-build (Step 10, fiori_deploy) or record why not.`);
+    }
     lines.push('Consider /abap-preflight on the produced transport(s) before release.');
     return lines;
 }

package/dist/projects/plan-schema.js

@@ -78,6 +78,8 @@ const planPhaseUiSchema = z.object({
     floorplan: z.enum(PLAN_UI_FLOORPLANS).optional(),
     appId: z.string().min(1).optional(),
     appTitle: z.string().min(1).optional(),
+    // The developer's own words for not deploying (checkRequiredDeploy, plan-lane.ts).
+    deployOptOut: z.string().min(1).optional(),
 });
 /** Keep in sync with PlanAuditState in types.ts. 'warn' is the non-blocking
  * tier (confidence-tiered redesign, 2026-07-08) — persisted literally so a

package/dist/projects/promote.js

@@ -1,4 +1,5 @@
 import { canonicalSha256 } from './canonicalize.js';
+import { safeDetailRel } from './detail-path.js';
 function itemTextFor(env, itemId) {
     if (env.artefactType === 'spec-gap') {
         for (const s of env.content.sections) {
@@ -105,7 +106,12 @@ export function buildReviewDecisionsBlock(source) {
  * makes readable — so we hand the skill that exact path to `file_read` directly.
  */
 export function buildDetailPathHint(source) {
-    const detailPath = source.content?.detailPath;
+    // SEC (review round 2): detailPath is envelope DATA (model-writable). Only a
+    // plain project-relative path into a skill working folder
+    // (.cspeach/<cca|upgrades|modernize|tests>/…) is handed to the skill as a
+    // file_read target — never an absolute path, `..`, a stream, a protected
+    // file, or text carrying a newline into the prompt.
+    const detailPath = safeDetailRel(source.content?.detailPath);
     if (!detailPath)
         return null;
     return [

package/dist/projects/save-command.js

@@ -18,7 +18,7 @@ import { renderEmailTemplate } from './email-template.js';
 import { writePlanHandover } from './handover-md.js';
 import { ensureWorkspace, resolveWorkspacePath } from './workspace.js';
 import { askYesNo, isYes } from './yes-no.js';
-import { checkLaneConsistency, LANE_CHANGED_AT_CREATE, readPlanLane } from './plan-lane.js';
+import { checkLaneConsistency, checkRequiredDeploy, LANE_CHANGED_AT_CREATE, readPlanLane } from './plan-lane.js';
 const SKILL_REGISTRY = {
     'abap-spec-gap': {
         artefactType: 'spec-gap',
@@ -343,7 +343,8 @@ export async function runSaveCommand(args) {
             args.log('[save] The plan was not saved.');
             return null;
         }
-        const conflict = checkLaneConsistency(planExtract.content, lr.rec);
+        // 2026-10-02 — a UI lane must deploy (or record the developer's opt-out).
+        const conflict = checkLaneConsistency(planExtract.content, lr.rec) ?? checkRequiredDeploy(planExtract.content, lr.rec);
         if (conflict) {
             args.log('');
             args.log(`[save] ${conflict}`);

package/dist/register/records.js

@@ -12,6 +12,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { classificationFromCcaDetail, fromCcaDetailKey, normalizeKey, normalizeRuleId, objectKey, } from '@cspeach/register-core';
 import { defaultRand, readBaseline } from './store.js';
+import { safeDetailRel, resolveDetailFileSync } from '../projects/detail-path.js';
 const FIX_STATUSES = new Set(['fixed', 'skipped', 'failed', 'pending']);
 export function writeRecord(joined, recordType, rows, by, opts = {}) {
     const known = new Set(readBaseline(joined.projectDir).map((o) => objectKey(o.type, o.name)));
@@ -69,8 +70,12 @@ export function writeRecord(joined, recordType, rows, by, opts = {}) {
  */
 export function decisionRowsFromCca(content, projectRoot) {
     const rows = new Map();
-    const detail = path.join(projectRoot, path.dirname(content.detailPath ?? ''), 'objects.json');
-    if (content.detailPath && fs.existsSync(detail)) {
+    // SEC (review round 2): detailPath is envelope DATA. objects.json is read only
+    // from beside a safe `.cspeach/cca/…` detail path, as a real file inside the
+    // project's cca working folder — never from an arbitrary location.
+    const rel = safeDetailRel(content.detailPath, 'cca');
+    const detail = rel ? resolveDetailFileSync(`${path.posix.dirname(rel)}/objects.json`, 'cca', projectRoot) : null;
+    if (detail) {
         try {
             const objects = JSON.parse(fs.readFileSync(detail, 'utf8'));
             for (const [detailKey, o] of Object.entries(objects ?? {})) {

package/dist/renderer/footer-line.js

@@ -80,18 +80,24 @@ export function formatFooterLine(s, width) {
 export function turnSpendText(p) {
     if (creditsActive()) {
         const c = p.credits;
-        if (!c || c.chargedThisTurn === null)
+        // 2026-10-02: the whole user request (every model round), not its last round.
+        if (!c || c.chargedThisRequest === null)
             return CREDITS_PENDING;
-        return formatCredits(c.chargedThisTurn, c.unitLabel);
+        return formatCredits(c.chargedThisRequest, c.unitLabel);
     }
     return p.costThisTurn != null ? formatCost(p.costThisTurn) : '';
 }
-/** `/<skill> · <tokens> tokens · <this-turn spend> · <time>` — one dim line, no newline. */
+/**
+ * `/<skill> · <tokens> tokens · <this-turn spend> · <time>` — one dim line, no newline.
+ * 2026-10-02 (owner): in credits mode (a managed customer) the token count is
+ * dropped — credits only, so nobody works out "credits per token".
+ */
 export function formatTurnReceipt(p) {
     const parts = [];
     if (p.skill && p.skill !== '(none)')
         parts.push(p.skill.startsWith('/') ? p.skill : `/${p.skill}`);
-    parts.push(`${p.tokens.toLocaleString('en-US')} tokens`);
+    if (!creditsActive())
+        parts.push(`${p.tokens.toLocaleString('en-US')} tokens`);
     if (p.spend)
         parts.push(p.spend);
     if (p.ms > 0)

package/dist/renderer/status-footer.js

@@ -71,13 +71,14 @@ export function formatStatusFooter(params) {
     const shortSession = sessionId.slice(0, 8);
     const skillDisplay = skill.startsWith('/') ? skill : `/${skill}`;
     const turns = `${turnCount} turn${turnCount === 1 ? '' : 's'}`;
-    const tokStr = tokens.toLocaleString() + ' tok this turn';
-    const cachedStr = cachedTokens > 0 ? `${cachedTokens.toLocaleString()} cached` : '';
-    const elapsed = elapsedMs > 0 ? `${(elapsedMs / 1000).toFixed(1)}s` : '';
     // Credits mode: the whole spend story collapses into ONE customer-facing
     // segment (turn · session · balance) in place of the two dollar segments.
     // (Classic receipt only — the Ink 'turn' variant returned above.)
+    // 2026-10-02 (owner): and no token/cached counts — credits only.
     const inCredits = creditsActive();
+    const tokStr = inCredits ? '' : tokens.toLocaleString() + ' tok this turn';
+    const cachedStr = !inCredits && cachedTokens > 0 ? `${cachedTokens.toLocaleString()} cached` : '';
+    const elapsed = elapsedMs > 0 ? `${(elapsedMs / 1000).toFixed(1)}s` : '';
     const costTurnStr = inCredits
         ? (credits ? formatCreditsLine(credits) : CREDITS_PENDING)
         : (costThisTurn != null ? formatCost(costThisTurn) : '');
@@ -92,7 +93,7 @@ export function formatStatusFooter(params) {
         sapAlias,
         skillDisplay,
         turns,
-        tokStr,
+        ...(tokStr ? [tokStr] : []),
         ...(costTurnStr ? [costTurnStr] : []),
         ...(cachedStr ? [cachedStr] : []),
         ...(costSessStr ? [costSessStr] : []),

package/dist/renderer/tool-labels.js

@@ -192,6 +192,7 @@ const RULES = {
     fiori_scaffold: (a) => ({ verb: 'Scaffolded app', object: shortLeft(str(a['basePath']) ?? '') }),
     fiori_apply: (a) => ({ verb: 'Applied', object: shortRight([str(a['entry']), str(a['appDir'])].filter(Boolean).join(' · ')) }),
     fiori_list: () => ({ verb: 'Listed patterns', object: '' }),
+    fiori_deploy: (a) => ({ verb: str(a['mode']) === 'deploy' ? 'Deploy app' : 'Deploy test', object: shortRight(str(a['appDir']) ?? '') }),
     fiori_deploy_config: (a) => ({ verb: 'Deploy config', object: shortRight(str(a['name']) ?? str(a['appDir']) ?? '') }),
     fiori_fe_extend: (a) => ({ verb: 'Extended app', object: shortRight([str(a['op']), str(a['basePath'])].filter(Boolean).join(' · ')) }),
     fiori_preview: (a) => ({ verb: 'Preview', object: shortRight([str(a['action']) ?? 'start', str(a['appDir'])].filter(Boolean).join(' ')) }),
@@ -258,7 +259,7 @@ const PRESENT = {
     'Read playbook': 'Reading playbook', 'Read convention': 'Reading convention', 'Merged CCA': 'Merging CCA',
     'Merged progress': 'Merging progress', 'Checked background': 'Checking background',
     Subagent: 'Running subagent', Reader: 'Running reader', 'Drafted schedule': 'Drafting schedule', Applied: 'Applying',
-    'Listed patterns': 'Listing patterns', 'Deploy config': 'Writing deploy config', 'Extended app': 'Extending app',
+    'Listed patterns': 'Listing patterns', 'Deploy config': 'Writing deploy config', 'Deploy app': 'Deploying app', 'Deploy test': 'Test-deploying app', 'Extended app': 'Extending app',
     Preview: 'Preview', 'Searched samples': 'Searching samples', 'Read sample': 'Reading sample',
     'Audited metadata': 'Auditing metadata', 'Extended model': 'Extending model',
     'Checked capability': 'Checking capability',

package/dist/repl.js

@@ -38,6 +38,7 @@ import { makeSessionId, saveSession, sessionSaved } from './session/store.js';
 import { newSession } from './session/schema.js';
 import { resolveModelRole } from './models/resolve.js';
 import { loadServerModelConfig, loadCustomerModelConfig, fetchToolLoadingMode } from './models/server-config.js';
+import { prefetchRouterPrompt } from './router/router-prompt.js';
 import { repinResumedSessionModel } from './session/repin-model.js';
 import { computeCost } from './cost/pricing.js';
 import { formatSessionSpendValue } from './repl/session-spend-line.js';
@@ -60,7 +61,7 @@ import { enqueueSteering } from './agent/steering-queue.js';
 import { classifyPrompt, parseShortcut, rejectUnknownSkill } from './router/classifier.js';
 import { pipedRoutingPick } from './router/piped-routing.js';
 import { decideRouting } from './router/routing-decision.js';
-import { routingFailureFromError, routingFailureFromResult, routingFailureNotice, routingFailureOutcome, routingFailureText } from './router/routing-failure.js';
+import { routingFailureFromError, routingFailureFromResult, routingFailureNotice, routingFailureOutcome, routingFailureText, routingFallbackFromError } from './router/routing-failure.js';
 import { coachingPickerClassic } from './ui/coaching-picker-classic.js';
 import { coachingPickerEmitter } from './ui/coaching-picker-emitter.js';
 import { globalStore as sapStateStore } from './ui/sap-state-store.js';
@@ -553,6 +554,9 @@ export async function runRepl(opts) {
         loadCustomerModelConfig(cfg, async () => apiKey ?? '', { timeoutMs: 1500 }),
         // Task 16 (F13) — BYOK reads only the served tool_loading (signed in only).
         fetchToolLoadingMode(cfg, async () => apiKey ?? '', { timeoutMs: 1500 }),
+        // 2026-10-02 — BYOK / ai-hub route on the laptop: prefetch the signed
+        // router prompt (public manifest, no prompt data) under the same cap.
+        cfg.llm?.mode === 'byok' || cfg.llm?.mode === 'ai-hub' ? prefetchRouterPrompt({ timeoutMs: 1500 }) : Promise.resolve(),
     ]);
     // Credits (2026-09-16) — resolve ONCE, before any cost figure can render.
     // A managed customer is billed in credits at a multiplier we do not
@@ -1318,8 +1322,16 @@ export async function runRepl(opts) {
                             }, { signal: routingCtl.signal });
                         }
                         catch (err) {
-                            if (!routingCtl.signal.aborted)
-                                throw err;
+                            if (!routingCtl.signal.aborted) {
+                                // Live fix 2026-10-02 — a classify failure (proxy HTTP 500,
+                                // an unreadable body) dropped the turn. Continue on the
+                                // bundled local rules: the offline handling below prints one
+                                // notice, then the low-confidence picker (or fix 10's stay).
+                                const fallback = routingFallbackFromError(err, prompt);
+                                if (!fallback)
+                                    throw err;
+                                c = fallback;
+                            }
                         }
                         finally {
                             routingAbort = null;
@@ -1467,6 +1479,8 @@ export async function runRepl(opts) {
                         // Task 9 — run-lease identity + takeover prompt (concurrent
                         // resume guard; inkAwarePrompt answers '' in headless = decline).
                         sessionId: session.id,
+                        // 2026-10-02 — deploy card on a direct resume into ui.deploy.
+                        sapAlias: session.sap_system ?? undefined,
                         prompt: inkAwarePrompt,
                         confirm: inkAwareConfirm,
                         log: (...lines) => chunkEmitter.emit('chunk', lines.join('\n') + '\n'),
@@ -1494,6 +1508,7 @@ export async function runRepl(opts) {
                             phaseIds: planResume.reauditPhaseIds ?? [planResume.reauditPhaseId],
                             sessionId: session.id,
                             cwd: process.cwd(),
+                            sapAlias: session.sap_system ?? undefined,
                             mode: planResume.effectiveMode ?? 'step',
                             modeFlag: planResume.mode,
                             // Off-switch (I3) — footer honesty on re-audit boards; (I2) the
@@ -1833,6 +1848,7 @@ export async function runRepl(opts) {
                         executedPhaseId: planResume.nextPhaseId,
                         sessionId: session.id,
                         cwd: process.cwd(),
+                        sapAlias: session.sap_system ?? undefined,
                         mode: planResume.effectiveMode ?? 'step',
                         modeFlag: planResume.mode,
                         // Off-switch — skips the normal post-phase audit when 'off'; the
@@ -1903,6 +1919,7 @@ export async function runRepl(opts) {
                         outcome: planOutcome,
                         sessionId: session.id,
                         cwd: process.cwd(),
+                        sapAlias: session.sap_system ?? undefined,
                         subagentDispatches: planSubagentDispatches,
                         prompt: inkAwarePrompt,
                         confirm: inkAwareConfirm,
@@ -3077,11 +3094,22 @@ export async function runRepl(opts) {
             }
             else {
                 try {
-                    const c = await classifyPrompt(prompt, {
-                        sap_system: selectedAlias,
-                        last_skill: session.last_skill ?? null,
-                        last_object: extractedObject ?? session.last_object ?? null,
-                    });
+                    let c;
+                    try {
+                        c = await classifyPrompt(prompt, {
+                            sap_system: selectedAlias,
+                            last_skill: session.last_skill ?? null,
+                            last_object: extractedObject ?? session.last_object ?? null,
+                        });
+                    }
+                    catch (err) {
+                        // Live fix 2026-10-02 — same as the Ink path: a classify failure
+                        // continues on the bundled local rules instead of ending the turn.
+                        const fallback = routingFallbackFromError(err, prompt);
+                        if (!fallback)
+                            throw err;
+                        c = fallback;
+                    }
                     if (c.screenshot)
                         console.log(formatInfo(`Screenshot: ${c.screenshot}`).trimEnd());
                     // Fix 10 (2026-09-26): routing failed mid-skill → stay in the
@@ -3214,6 +3242,8 @@ export async function runRepl(opts) {
                     configAudit: cfg.plan_audit,
                     // Task 9 — run-lease identity + takeover prompt (classic mirror).
                     sessionId: session.id,
+                    // 2026-10-02 — deploy card on a direct resume into ui.deploy.
+                    sapAlias: session.sap_system ?? undefined,
                     prompt: inkAwarePrompt,
                     confirm: inkAwareConfirm,
                     log: (...lines) => lines.forEach((l) => console.log(l)),
@@ -3240,6 +3270,7 @@ export async function runRepl(opts) {
                         phaseIds: planResume.reauditPhaseIds ?? [planResume.reauditPhaseId],
                         sessionId: session.id,
                         cwd: process.cwd(),
+                        sapAlias: session.sap_system ?? undefined,
                         mode: planResume.effectiveMode ?? 'step',
                         modeFlag: planResume.mode,
                         // Off-switch (I3/I2) — classic mirror; see the Ink re-audit site.
@@ -3551,6 +3582,7 @@ export async function runRepl(opts) {
                     executedPhaseId: planResume.nextPhaseId,
                     sessionId: session.id,
                     cwd: process.cwd(),
+                    sapAlias: session.sap_system ?? undefined,
                     mode: planResume.effectiveMode ?? 'step',
                     modeFlag: planResume.mode,
                     // Off-switch (I3/I2) — classic mirror of the Ink chain call: skip
@@ -3620,6 +3652,7 @@ export async function runRepl(opts) {
                     outcome: planOutcome,
                     sessionId: session.id,
                     cwd: process.cwd(),
+                    sapAlias: session.sap_system ?? undefined,
                     subagentDispatches: planSubagentDispatches,
                     prompt: inkAwarePrompt,
                     confirm: inkAwareConfirm,