@cspeach/cli 0.9.0 → 1.0.0

package/dist/classifier/client.js

@@ -8,8 +8,10 @@ const RULES = [
     { skill: 'abap-document', patterns: [/developer\s+documentation|document\s+this\s+(class|program|object)/i] },
     // abap-incident MUST precede dump rules — pipeline framing beats keyword-only matches
     { skill: 'abap-incident', patterns: [/incident|resolve.*dump.*to.*fix|pipeline.*(short\s+dump|st22|dump)|(dump|st22).*to.*transport|formal\s+(incident|dump)\s+report|end.to.end.*dump/i] },
-    { skill: 'abap-dump-triage', patterns: [/dump\s+triage|structured\s+investigation.*dump|dump\s+forensic/i] },
-    { skill: 'abap-dump-analyze', patterns: [/short\s+dump|runtime\s+error|\bst22\b|dump\s+analys/i] },
+    // abap-dump (2026-06-12) — merger of abap-dump-analyze + abap-dump-triage.
+    // Triage-vs-fix is an intent decision INSIDE the skill now, so both
+    // pattern sets route here.
+    { skill: 'abap-dump', patterns: [/short\s+dump|runtime\s+error|\bst22\b|dump\s+(analys|triage|forensic)|structured\s+investigation.*dump/i] },
     { skill: 'abap-eml', patterns: [/\beml\b|entity\s+manipulation|behavior\s+handler/i] },
     { skill: 'abap-enhance', patterns: [/\bbadi\b|enhancement\s+spot|implicit\s+enhancement|customer\s+exit|user\s+exit|(hook\s+into|extend)\s+(sap|standard|me\d+|migo|miro|va\d+|vf\d+|vl\d+|fb\d+)/i] },
     { skill: 'abap-estimate', patterns: [/effort\s+estimat|ticket\s+estimat|size\s+this\s+(work|task|ticket|story)|how\s+(many|long).*(hours|days).*(build|develop|implement)/i] },
@@ -20,11 +22,24 @@ const RULES = [
     // abap-modernize MUST precede abap-rap so "rebuild as RAP" / "convert to RAP" stays
     // on modernize (rebuild intent) instead of falling to abap-rap's bare \brap\b match.
     { skill: 'abap-modernize', patterns: [/modernise|modernize|classic.*to.*modern|convert.*to\s+(rap|fiori|odata)|rebuild.*as\s+(rap|fiori)/i] },
+    // abap-fiori-build (D12, 2026-06-12) MUST follow abap-modernize ("convert
+    // this WRITE report to Fiori" = rebuild intent) and precede abap-rap so
+    // "fiori app for my RAP/OData service" lands on the UI skill, not the
+    // backend scaffolder.
+    { skill: 'abap-fiori-build', patterns: [/\bfiori\b|\b(sap)?ui5\b|freestyle\s+app|\bui\s+app\b|front.?end\s+(for|on)\s/i] },
     // abap-rap MUST precede abap-generate so RAP-stack prompts route to rap, not the
     // generic generator (cluster I, 2026-05-03). Also captures "scaffold a CDS view +
     // BDEF + service binding" type prompts which collide with abap-generate.
     { skill: 'abap-rap', patterns: [/\brap\b|business\s+object(?!s?\s+for)|bdef|service\s+binding|srvb|scaffold.*(cds|odata\s+v4|bdef|behavior)|odata\s+v4\s+service/i] },
-    { skill: 'abap-generate', patterns: [/\bgenerate\b|create\s+(a\s+)?(new\s+)?(class|program|report|include)|build.*from\s+scratch/i] },
+    // Daily-edit phrasings (D12, 2026-06-12): "add a validation to ZCL_X",
+    // "change/fix ZFOO" are abap-generate work — the old rules only matched
+    // explicit "generate"/"create" verbs, so daily edits fell through and the
+    // coaching picker offered enhance/refactor/test instead.
+    { skill: 'abap-generate', patterns: [
+            /\bgenerate\b|create\s+(a\s+)?(new\s+)?(class|program|report|include)|build.*from\s+scratch/i,
+            /\badd\s+(a\s+|an\s+)?[\w\s-]{1,40}\bto\s+z[_a-z0-9]+/i,
+            /\b(change|fix|update|modify|adjust)\s+(the\s+)?z[_a-z0-9]+\b/i,
+        ] },
     { skill: 'abap-impact', patterns: [/impact\s+analysis|where.*used|what.*affected\s+by/i] },
     // abap-upgrade-* must precede abap-migrate
     { skill: 'abap-upgrade-verify', patterns: [/upgrade\s+verify|remediation\s+report|verify\s+upgrade/i] },

package/dist/commands/config-set.js

@@ -10,6 +10,8 @@ const MUTABLE_KEYS = new Set([
     'effort',
     'telemetry',
     'classifier.safe_mode',
+    'local_build',
+    'local_files', // deprecated alias for local_build (2026-06-13) — still accepted
     'write_mode',
     'llm.mode',
     'llm.ai_hub_base_url',
@@ -22,6 +24,25 @@ const MUTABLE_KEYS = new Set([
 ]);
 // SAP-scoped key pattern: sap.<alias>.auto_approve
 const SAP_AUTO_APPROVE_RE = /^sap\.([A-Z0-9_-]{2,32})\.auto_approve$/;
+// SAP-scoped TLS keys: sap.<alias>.ca_cert_path | sap.<alias>.insecure_skip_tls_verify
+const SAP_CA_CERT_PATH_RE = /^sap\.([A-Z0-9_-]{2,32})\.ca_cert_path$/;
+const SAP_INSECURE_TLS_RE = /^sap\.([A-Z0-9_-]{2,32})\.insecure_skip_tls_verify$/;
+/**
+ * Coerce a user-typed on/off-style string to a boolean. Accepts the common
+ * spellings a developer expects from a CLI toggle (`on`/`true`/`1` → true,
+ * `off`/`false`/`0` → false). Returns null for anything else so the caller
+ * can reject with a clear error. Case-insensitive.
+ */
+const TRUE_TOKENS = new Set(['on', 'true', '1']);
+const FALSE_TOKENS = new Set(['off', 'false', '0']);
+function coerceBool(value) {
+    const v = value.trim().toLowerCase();
+    if (TRUE_TOKENS.has(v))
+        return true;
+    if (FALSE_TOKENS.has(v))
+        return false;
+    return null;
+}
 const EFFORT_VALUES = ['low', 'medium', 'high', 'xhigh', 'max'];
 const TELEMETRY_VALUES = ['minimal', 'full'];
 const AUTO_APPROVE_VALUES = ['never', 'low', 'medium'];
@@ -73,6 +94,45 @@ export async function runConfigSet(args) {
         console.log(chalk.green(`Set ${key} = ${value}`));
         return;
     }
+    // SAP-scoped TLS: sap.<alias>.ca_cert_path — trust a CA, verification STAYS ON.
+    const caMatch = SAP_CA_CERT_PATH_RE.exec(key);
+    if (caMatch) {
+        const alias = caMatch[1];
+        const cfg = await loadConfig();
+        if (!cfg.sap[alias]) {
+            err(`SAP system "${alias}" not found in config. Add it first with: cspeach config add-sap`);
+        }
+        // Path is stored as-is (no existence check here — the connection fails loudly
+        // and fail-closed if the CA can't be read at connect time). Setting a CA also
+        // clears any insecure flag so the two never conflict.
+        cfg.sap[alias].ca_cert_path = value;
+        delete cfg.sap[alias].insecure_skip_tls_verify;
+        await saveConfig(cfg);
+        console.log(chalk.green(`Set ${key} = ${value}`));
+        console.log(chalk.dim('  → TLS verification stays ON; this CA is added to the trust store.'));
+        return;
+    }
+    // SAP-scoped TLS: sap.<alias>.insecure_skip_tls_verify — dev-only opt-out.
+    const insecMatch = SAP_INSECURE_TLS_RE.exec(key);
+    if (insecMatch) {
+        const alias = insecMatch[1];
+        const b = coerceBool(value);
+        if (b === null) {
+            err(`${key} must be on/off (also accepts true/false, 1/0).`);
+        }
+        const cfg = await loadConfig();
+        if (!cfg.sap[alias]) {
+            err(`SAP system "${alias}" not found in config. Add it first with: cspeach config add-sap`);
+        }
+        cfg.sap[alias].insecure_skip_tls_verify = b;
+        if (b) {
+            console.log(chalk.yellow(`  ⚠ TLS verification will be DISABLED for ${alias} — dev only, NEVER use in production. ` +
+                `Prefer: cspeach config set sap.${alias}.ca_cert_path <path-to-corporate-CA>`));
+        }
+        await saveConfig(cfg);
+        console.log(chalk.green(`Set ${key} = ${b}`));
+        return;
+    }
     // Virtual keys that store secrets in the OS keychain instead of config.toml.
     if (key === 'llm.byok_key' || key === 'llm.ai_hub_token') {
         // Support stdin piping for secrets: `echo "key" | cspeach config set llm.byok_key -`
@@ -142,6 +202,31 @@ export async function runConfigSet(args) {
             }
             cfg.classifier.safe_mode = value === 'true';
             break;
+        case 'local_files':
+            // Deprecated alias (2026-06-13). Still applied — but it WRITES to the new
+            // `local_build` key so the user's config converges on the new name. The
+            // shared `local_build` case below also DELETES any stale legacy
+            // `local_files` key so it doesn't linger after migration. One-line
+            // deprecation note, then fall through.
+            console.log(chalk.yellow('  → "local_files" is deprecated; use "local_build". Applying to local_build.'));
+        // fallthrough
+        case 'local_build': {
+            const b = coerceBool(value);
+            if (b === null) {
+                err(`${key} must be on/off (also accepts true/false, 1/0).`);
+            }
+            cfg.local_build = b;
+            // Migration hygiene (2026-06-13): whether the user typed `local_build` or
+            // the deprecated `local_files` alias, we write the new key AND drop any
+            // stale legacy `local_files` so it doesn't linger in `config show` after
+            // migration. resolveLocalBuild prefers local_build anyway, but a leftover
+            // legacy key is confusing and could surprise a future reader.
+            delete cfg.local_files;
+            // Config is read at startup; a running session isn't retroactively
+            // changed (the tool override is applied once, before the first turn).
+            console.log(chalk.dim('  → takes effect on the next `cspeach` launch.'));
+            break;
+        }
         case 'write_mode':
             if (!isValidWriteMode(value)) {
                 err(`Invalid value for write_mode. Must be one of: auto, approval-gated, advisory-only`);
@@ -201,6 +286,13 @@ export function validateValue(key, value) {
     if (SAP_AUTO_APPROVE_RE.test(key)) {
         return AUTO_APPROVE_VALUES.includes(value);
     }
+    // SAP-scoped TLS keys.
+    if (SAP_CA_CERT_PATH_RE.test(key)) {
+        return value.length > 0; // any non-empty path; existence checked at connect
+    }
+    if (SAP_INSECURE_TLS_RE.test(key)) {
+        return coerceBool(value) !== null;
+    }
     if (!MUTABLE_KEYS.has(key))
         return false;
     switch (key) {
@@ -220,6 +312,9 @@ export function validateValue(key, value) {
             return TELEMETRY_VALUES.includes(value);
         case 'classifier.safe_mode':
             return value === 'true' || value === 'false';
+        case 'local_build':
+        case 'local_files': // deprecated alias — same on/off coercion
+            return coerceBool(value) !== null;
         case 'write_mode':
             return isValidWriteMode(value);
         case 'llm.mode':

package/dist/commands/login.js

@@ -13,7 +13,11 @@
  * Dependencies (open, print, prompt) are injected so the command is
  * unit-testable without stubbing platform globals.
  */
+import keytar from 'keytar';
 import { writeAuthFile } from '../auth/auth-file.js';
+import { fetchOrgAnthropicKey } from '../auth/org-anthropic-key.js';
+const ANTHROPIC_KEYCHAIN_SERVICE = 'cspeach.anthropic';
+const ANTHROPIC_KEYCHAIN_ACCOUNT = 'api-key';
 export async function runLoginCommand(deps) {
     const proxy = deps.proxyUrl.replace(/\/$/, '');
     const pollInterval = deps.pollIntervalMs ?? 5000;
@@ -92,22 +96,35 @@ export async function runLoginCommand(deps) {
             const me = await r.json();
             deps.print(`✓ Signed in as ${me.email} (${me.plan})`);
             if (me.trial_mode === 'byok' || me.plan === 'byo-key') {
-                deps.print('');
-                deps.print('This account is BYOK — you provide your own Anthropic API key.');
-                deps.print('Get one at https://console.anthropic.com/settings/keys');
-                const ak = (await deps.prompt('Paste your Anthropic API key (sk-ant-...): ')).trim();
-                if (ak.startsWith('sk-ant-') && ak.length > 20) {
-                    // The non-BYOK save above just persisted these exact values,
-                    // so reading them back from disk would be redundant.
-                    await writeAuthFile({
-                        apiKey: polled.api_key,
-                        customerId: polled.customer_id,
-                        byokAnthropicKey: ak,
-                    });
-                    deps.print('✓ Anthropic key saved');
+                // Try to fetch the org's Anthropic key first — non-fatal if unavailable.
+                const orgKey = await fetchOrgAnthropicKey(proxy, polled.api_key, {
+                    fetchImpl: deps.fetchImpl,
+                });
+                const setKey = deps.setKeychainKey ??
+                    ((svc, acct, k) => keytar.setPassword(svc, acct, k));
+                if (orgKey !== null) {
+                    await setKey(ANTHROPIC_KEYCHAIN_SERVICE, ANTHROPIC_KEYCHAIN_ACCOUNT, orgKey);
+                    deps.print('Using your organization\'s Anthropic key.');
                 }
                 else {
-                    deps.print('error: Anthropic key looks malformed (must start with sk-ant-). Skipped — run `cspeach login` again later.');
+                    // Fall back to the manual paste prompt — behaviour unchanged.
+                    deps.print('');
+                    deps.print('This account is BYOK — you provide your own Anthropic API key.');
+                    deps.print('Get one at https://console.anthropic.com/settings/keys');
+                    const ak = (await deps.prompt('Paste your Anthropic API key (sk-ant-...): ')).trim();
+                    if (ak.startsWith('sk-ant-') && ak.length > 20) {
+                        // The non-BYOK save above just persisted these exact values,
+                        // so reading them back from disk would be redundant.
+                        await writeAuthFile({
+                            apiKey: polled.api_key,
+                            customerId: polled.customer_id,
+                            byokAnthropicKey: ak,
+                        });
+                        deps.print('✓ Anthropic key saved');
+                    }
+                    else {
+                        deps.print('error: Anthropic key looks malformed (must start with sk-ant-). Skipped — run `cspeach login` again later.');
+                    }
                 }
             }
         }

package/dist/commands/plan-model-tier.js

@@ -0,0 +1,83 @@
+// A4 (2026-06-11) — per-phase model tiering for the plan runner.
+//
+// Cost-control Phase 3, pre-approved by the 2026-05-18 model bench
+// (cspeach-cli/scripts/bench-models.ts): Sonnet matches Opus on
+// explain/document/test/design-shaped ABAP work at ~85% lower cost, while
+// Haiku is UNSAFE on ABAP content (hallucinates SAP terms — bench memo) and
+// is therefore NEVER a tiering target here.
+//
+// FLAG-GATED, OFF BY DEFAULT. Two switches, env wins when set:
+//   - config:  plan_model_tiering = true        (~/.cspeach/config.toml)
+//   - env:     CSPEACH_PLAN_MODEL_TIERING=on    (also 1/true; off/0/false force-disable)
+//
+// Classification is STRUCTURAL, not id-string parsing: each plan phase
+// carries a `delegateTo` skill (Zod enum PLAN_DELEGATE_SKILLS in
+// projects/plan-schema.ts). Only the read/reason-shaped skills the bench
+// cleared go to Sonnet; every write/codegen delegate — and anything
+// ambiguous or unknown — stays on the session's default model.
+//
+// Extra guard: tiering only fires when the session default is Opus-family.
+// A user who deliberately set default_model to Sonnet (or anything cheaper)
+// must never be silently moved to a different model by this feature.
+//
+// Wiring (single read path): repl.tsx computes the choice right after
+// preparePlanResume succeeds (both Ink and classic paths), prints the dim
+// notice for cost auditability, and threads the model into runTurn via
+// RunTurnParams.modelOverride — which also feeds the per-turn cost-log
+// entry so ~/.cspeach/sessions/<id>-cost.jsonl records the ACTUAL model.
+/** The only model this feature ever tiers down to. Never Haiku. */
+export const PLAN_TIER_SONNET_MODEL = 'claude-sonnet-4-6';
+/**
+ * Delegate skills whose phases are design/test/document-shaped — the shapes
+ * the 2026-05-18 bench cleared for Sonnet. `abap-document` is not in
+ * PLAN_DELEGATE_SKILLS today; included so an enum extension is covered
+ * without touching this file. Everything else (abap-data-model, abap-rap,
+ * abap-eml, abap-generate, abap-segw, abap-fiori-build) writes SAP objects
+ * or code and stays on the default model.
+ */
+export const SONNET_TIER_DELEGATES = new Set([
+    'abap-design',
+    'abap-test',
+    'abap-document',
+]);
+const ENV_FLAG = 'CSPEACH_PLAN_MODEL_TIERING';
+/**
+ * Resolve the feature flag. Env var (when set) wins over config so a single
+ * shell can A/B the feature without editing config.toml; the config flag is
+ * the persistent opt-in. Strict `=== true` on the config value — TOML is
+ * hand-edited, and a typo'd string must read as OFF, never ON.
+ */
+export function isPlanModelTieringEnabled(cfg, env = process.env) {
+    const raw = env[ENV_FLAG];
+    if (raw !== undefined && raw !== '') {
+        const v = raw.trim().toLowerCase();
+        return v === 'on' || v === '1' || v === 'true';
+    }
+    return cfg.plan_model_tiering === true;
+}
+const NO_OVERRIDE = { model: null, notice: null };
+/**
+ * Pure decision function: which model should this plan phase run on?
+ *
+ * Returns an override ONLY when all of:
+ *   - the flag is on,
+ *   - the phase's delegateTo is a bench-cleared design/test/document shape,
+ *   - the session default is an Opus-family model (we only tier DOWN from
+ *     Opus — never sideways/up from a deliberately cheaper default).
+ *
+ * Anything ambiguous resolves to "no override". The returned model is
+ * claude-sonnet-4-6 or nothing — Haiku is unreachable by construction
+ * (pinned in plan-model-tier.test.ts).
+ */
+export function selectPlanPhaseModel(args) {
+    if (!args.enabled)
+        return NO_OVERRIDE;
+    if (!args.delegateTo || !SONNET_TIER_DELEGATES.has(args.delegateTo))
+        return NO_OVERRIDE;
+    if (!/opus/i.test(args.defaultModel))
+        return NO_OVERRIDE;
+    return {
+        model: PLAN_TIER_SONNET_MODEL,
+        notice: `phase ${args.phaseId} → ${PLAN_TIER_SONNET_MODEL} (plan model tiering)`,
+    };
+}

package/dist/commands/plan-resume.js

@@ -16,7 +16,20 @@
 //     precede a closing ask_question, see turn-assistant-text.ts) →
 //     extract the LAST csforge:plan-manifest block → build the version
 //     N+1 revision (same id, history appended) → save → print the
-//     updated tracker + next-step hint.
+//     updated tracker + next-step hint → return the saved path + the
+//     HARNESS-built resume command for the next phase (A1, 2026-06-10).
+//
+// A1 (defect D23) — true bounded phases: phase end = turn end.
+//   The model's resume turn ends at the manifest block. It must NOT ask a
+//   continuation question, NOT call dispatch_skill, and NOT execute a
+//   second phase in-turn (the old contract allowed in-session "continue",
+//   which snowballed a 6-phase run into one 3.24M-token-context session).
+//   Continuation is harness-owned: repl.tsx calls offerNextPhaseAutoRun
+//   with the PlanResumeOutcome; on consent it queues the EXACT command
+//   buildResumeCommand produced from the just-saved path (the model once
+//   hallucinated a wrong base when it authored this text itself), and
+//   every plan-resume turn starts from reset session messages
+//   (resetContextForPlanResume).
 //
 // The save hook inside runTurn is suppressed for resume turns
 // (RunTurnParams.suppressSaveHook) — it would otherwise offer to save a
@@ -28,12 +41,22 @@ import { basename, dirname, join } from 'node:path';
 import { readProjectFile } from '../projects/status.js';
 import { resolveAtTokenAsync, formatProjectFileList, ensureWorkspace } from '../projects/workspace.js';
 import { parsePlanContent } from '../projects/plan-schema.js';
-import { statusesFromItems, computeNextPhase, renderPlanTracker, buildPlanRevision, } from '../projects/plan-run.js';
+import { statusesFromItems, computeNextPhase, renderPlanTracker, buildPlanRevision, isPhaseSatisfied, planCompletionLines, } from '../projects/plan-run.js';
 import { extractPlan } from '../projects/extract-plan.js';
 import { saveProject } from '../projects/save.js';
 import { validateEnvelope } from '../projects/validate.js';
 import { collectTurnAssistantText } from '../agent/turn-assistant-text.js';
 import { getAuthorIdentity } from '../agent/loop.js';
+/**
+ * A1 (defect D23) — the harness-owned continuation contract, stated to the
+ * model verbatim in every resume prompt: the manifest ends the turn; the
+ * model must not call dispatch_skill or ask a continuation question — the
+ * CLI dispatches the next phase itself. Exported as a named constant so
+ * tests pin the prompt to this exact block instead of brittle prose
+ * regexes (the old contract let the model keep executing phases in-turn —
+ * a 6-phase run once snowballed to a 3.24M-token context).
+ */
+export const PLAN_RESUME_HARNESS_OVERRIDE = 'HARNESS OVERRIDE of the skill\'s Mode 2 step 8: do NOT ask a continuation question, do NOT call dispatch_skill, and NEVER start another phase in this turn. After your manifest is persisted, the CLI itself asks the user whether to run the next phase and dispatches it with the exact saved file in a fresh bounded context. Phase end = turn end.';
 export async function preparePlanResume(args) {
     const tokens = args.body
         .split(/\s+/)
@@ -116,10 +139,14 @@ export async function preparePlanResume(args) {
     }));
     args.log('');
     if (!next) {
-        const allValidated = content.phases.every((p) => statuses[p.id] === 'validated');
+        // C1 (D30 waiver): 'validated-with-waiver' is satisfied — a plan whose
+        // last gate was explicitly waived is complete, not stuck.
+        const allValidated = content.phases.every((p) => isPhaseSatisfied(statuses[p.id]));
         if (allValidated) {
-            args.log('Plan complete — every phase is validated.');
-            args.log('Consider /abap-preflight on the produced transport(s) before release.');
+            // C2 (D24): a finished UI-less backend stack chains to /abap-fiori-build
+            // with the exact binding name — the marketed idea→app story must not
+            // silently end at the service binding.
+            args.log(...planCompletionLines(content.phases));
         }
         else {
             const blocked = content.phases.filter((p) => statuses[p.id] === 'blocked').map((p) => p.id);
@@ -143,10 +170,39 @@ export async function preparePlanResume(args) {
         }
     }
     const planState = JSON.stringify({ title: envelope.title, version: envelope.version, statuses, content }, null, 2);
+    // A2 (defects D23/D30) — compact write-back: the model re-emitting the
+    // full plan content every phase cost ~6–10k output tokens/phase at Opus
+    // pricing for data the envelope already holds. The resume turn emits
+    // statuses + a `changed` entry for the executed phase only; extractPlan
+    // merges it into the prior content. The example is built with the REAL
+    // phase ids and current statuses so the model copies, not reconstructs.
+    const compactExample = [
+        '<!-- csforge:plan-manifest',
+        JSON.stringify({
+            title: envelope.title,
+            statuses: { ...statuses, [next.id]: '<validated | validated-with-waiver | blocked>' },
+            changed: {
+                [next.id]: {
+                    work: {
+                        generated: ['<object names created/changed>'],
+                        transport: '<transport number — omit the key if none>',
+                        // C2 (D24): the service phase records the published SRVB name in
+                        // work.binding — the plan-complete message hands it to
+                        // /abap-fiori-build. Only shown when this turn IS the service phase.
+                        ...(next.layer === 'service'
+                            ? { binding: '<published service binding name, e.g. ZUI_MAINTREQ_O4>' }
+                            : {}),
+                        notes: '<decisions, substitutions, blocker details worth keeping — omit if none>',
+                    },
+                },
+            },
+        }, null, 2),
+        '-->',
+    ].join('\n');
     const llmPrompt = [
         `Resume execution of the project plan "${envelope.title}" (envelope v${envelope.version}).`,
         '',
-        `Execute Mode 2 of the abap-plan skill for phase "${next.id}" ONLY — it is the computed next eligible phase. Do not execute any other phase unless the user explicitly picks "continue" at the phase-end question.`,
+        `Execute Mode 2 of the abap-plan skill for phase "${next.id}" ONLY — it is the computed next eligible phase. Never execute any other phase in this turn; the CLI itself offers and dispatches the next phase (in a fresh bounded context) after this one is persisted.`,
         '',
         '<plan_state>',
         planState,
@@ -156,13 +212,26 @@ export async function preparePlanResume(args) {
         ...ruleBlocks,
         '</phase_rules>',
         '',
-        // 2026-06-06 live-smoke lesson #3: the model asked the continuation
-        // question FIRST, then ended the turn on the user's "exit" answer with
-        // a one-line acknowledgment — and the whole phase result was lost. The
-        // ordering must be explicit and the consequence named.
-        'CRITICAL — write-back ordering: emit the COMPLETE updated <!-- csforge:plan-manifest --> block (full phase list, statuses entry for every phase, this phase\'s work filled in — including work.notes with the compact decision register when the phase produced decisions rather than SAP objects) BEFORE the phase-end continuation question. The manifest block is how the result is persisted; a turn that ends without it LOSES the phase. After the user answers "exit", reply with at most one short line — the manifest must already be in the transcript by then.',
+        // A1 (2026-06-10, defect D23): the old contract let the model ask a
+        // continuation question and keep executing phases in-turn — a 6-phase
+        // run snowballed to a 3.24M-token context because the turn never
+        // ended. The manifest now ENDS the turn; the harness owns continuation
+        // (offerNextPhaseAutoRun) and dispatches the next phase itself with
+        // the exact saved path, in reset context.
+        'CRITICAL — the write-back ENDS the turn: emit ONE COMPACT <!-- csforge:plan-manifest --> block as the LAST thing in your output, then END THE TURN. Compact shape = "title" + a "statuses" entry for EVERY phase + a "changed" map carrying ONLY the phase(s) you touched this turn (normally exactly this one). Each "changed" entry holds the phase\'s COMPLETE updated "work" (generated / transport / snapshot / notes — put the compact decision register in work.notes when the phase produced decisions rather than SAP objects); it replaces that phase\'s prior work wholesale. Do NOT re-emit "content" or the full phase list — the CLI already holds the full plan, merges your "changed" entries into it, and recomputes the summary. Exact shape for this turn:',
+        '',
+        compactExample,
+        '',
+        // C1 (D30 waiver) — the waiver status exists so an explicitly-waived exit
+        // gate is recorded as what it is, instead of being laundered into a
+        // "validated" the gate never earned (the c1.test AUnit-gap incident).
+        'Status rules: "validated" ONLY when the exit gate actually held and was verified. If the gate could NOT be met but the user EXPLICITLY waived it this turn (e.g. "skip the test gate, continue anyway"), use "validated-with-waiver" and record what was waived and why in work.notes — never mark an unmet gate "validated", and never use the waiver status without an explicit user waiver. Otherwise the phase is "blocked".',
+        '',
+        'Only if the plan itself must change structurally (a phase added, removed, or re-sequenced) fall back to the full shape with "content" — the CLI accepts both. The manifest block is how the result is persisted; a turn that ends without it LOSES the phase.',
+        '',
+        PLAN_RESUME_HARNESS_OVERRIDE,
     ].join('\n');
-    return { path, envelope, statuses, nextPhaseId: next.id, llmPrompt };
+    return { path, envelope, statuses, nextPhaseId: next.id, nextDelegateTo: next.delegateTo, llmPrompt };
 }
 /**
  * Given a set of candidate file paths (e.g. the matches from an ambiguous
@@ -193,14 +262,57 @@ export function pickNewestPlanVersion(paths) {
     return items[0].path;
 }
 /**
- * True when a queued dispatch command is a `/abap-plan --resume …`. The REPL
- * uses this to clear session.messages before re-entering, so the auto-fired
- * next phase runs in fresh, bounded context (the cheap path).
+ * True when a queued dispatch command is a `/abap-plan --resume …`.
+ * Consumer: dispatch_skill REJECTS model-authored plan-resume dispatches
+ * (A1 — the harness owns that command; the model once hallucinated a wrong
+ * base token). The transcript clear for resume turns is owned solely by
+ * resetContextForPlanResume, called from the REPL's plan-resume prepare
+ * branch after preparePlanResume succeeds.
  */
 export function isPlanResumeCommand(cmd) {
     const c = cmd.trim();
     return /^\/abap-plan\b/.test(c) && /(^|\s)--resume(\s|$)/.test(c);
 }
+/**
+ * A1 (defect D23) — the HARNESS builds the next-phase resume command from
+ * the exact path finishPlanResume just saved. Single construction site:
+ * the model never authors this text (it once invented `@…-plan-c1` when
+ * the real file was `…-plan-c9b3-v14.cspeach.json`). The basename keeps
+ * the version suffix — it resolves to that exact file, and the
+ * newest-version redirect in preparePlanResume still protects against a
+ * concurrent later save.
+ */
+export function buildResumeCommand(savedPath) {
+    return `/abap-plan --resume @${basename(savedPath)}`;
+}
+/**
+ * A1 — every plan-resume turn starts from RESET session messages: the
+ * envelope + the bounded preparePlanResume prompt carry all needed state,
+ * so prior-phase (or prior-chat) transcript is pure cost. Called by the
+ * REPL right after preparePlanResume succeeds, which covers BOTH the
+ * harness-dispatched auto-run path and a manually typed `--resume`.
+ * Returns true when messages were actually cleared (caller logs a notice).
+ * Property reassignment (not splice) — session.messages consumers always
+ * re-read the property.
+ */
+export function resetContextForPlanResume(session) {
+    if (session.messages.length === 0)
+        return false;
+    session.messages = [];
+    return true;
+}
+export async function offerNextPhaseAutoRun(args) {
+    if (!args.outcome.nextPhaseId)
+        return false;
+    const delegate = args.outcome.nextDelegateTo ? ` (${args.outcome.nextDelegateTo})` : '';
+    const answer = (await args.prompt(`Run next phase ${args.outcome.nextPhaseId}${delegate} now in a fresh context? [y/N]: `)).trim().toLowerCase();
+    if (answer !== 'y' && answer !== 'yes') {
+        args.log(`Exiting — resume later with: ${args.outcome.resumeCommand}`);
+        return false;
+    }
+    args.queueDispatch(args.outcome.resumeCommand);
+    return true;
+}
 /**
  * Find the newest sibling version of the envelope at `path` — same
  * filename family (`<slug>-<shortid>-vN[...]`) AND same envelope id (the
@@ -250,11 +362,18 @@ export async function finishPlanResume(args) {
         args.log('');
         args.log('[plan] turn produced no assistant output — plan envelope UNCHANGED.');
         args.log(`[plan] re-run: /abap-plan --resume @${basename(args.prepared.path)}`);
-        return;
+        return null;
     }
     let extract;
     try {
-        extract = extractPlan(text);
+        // A2 — pass the prior content so a COMPACT manifest (statuses + changed
+        // map) can be merged into it. prepared.envelope.content already passed
+        // parsePlanContent in preparePlanResume; re-parsing here hands extractPlan
+        // the normalised PlanContent without widening PreparedPlanResume. If the
+        // parse somehow fails, prior stays undefined and a compact manifest fails
+        // loudly below (full manifests are unaffected).
+        const prior = parsePlanContent(args.prepared.envelope.content);
+        extract = extractPlan(text, prior.ok ? prior.content : undefined);
     }
     catch (e) {
         // Loud by design: the phase may have built real SAP objects, but the
@@ -265,14 +384,15 @@ export async function finishPlanResume(args) {
         args.log('[plan] The plan envelope is unchanged. Check what the phase actually built');
         args.log('[plan] (transport, activated objects), update the envelope statuses by hand or');
         args.log(`[plan] re-run: /abap-plan --resume @${basename(args.prepared.path)}`);
-        return;
+        return null;
     }
     const revision = buildPlanRevision(args.prepared.envelope, extract, getAuthorIdentity(), new Date().toISOString());
+    // JSON round-trip simulates disk serialization for the validator.
     const check = validateEnvelope(JSON.parse(JSON.stringify(revision)));
     if (!check.ok) {
         args.log('');
         args.log(`[plan] PHASE RESULT NOT PERSISTED — revision failed validation: ${check.error.message}`);
-        return;
+        return null;
     }
     let outDir;
     try {
@@ -298,11 +418,18 @@ export async function finishPlanResume(args) {
     if (next) {
         args.log(`Next: ${next.id} (${next.delegateTo}) — run /abap-plan --resume @${basename(savedPath)} in a fresh session.`);
     }
-    else if (extract.content.phases.every((p) => statuses[p.id] === 'validated')) {
-        args.log('Plan complete — every phase validated. Consider /abap-preflight before release.');
+    else if (extract.content.phases.every((p) => isPhaseSatisfied(statuses[p.id]))) {
+        // C2 (D24): same chain as preparePlanResume — single source in plan-run.ts.
+        args.log(...planCompletionLines(extract.content.phases));
     }
     else {
         const blocked = extract.content.phases.filter((p) => statuses[p.id] === 'blocked').map((p) => p.id);
         args.log(`No eligible next phase. Blocked: ${blocked.join(', ')}. Unblock, then resume again.`);
     }
+    return {
+        savedPath,
+        resumeCommand: buildResumeCommand(savedPath),
+        nextPhaseId: next?.id ?? null,
+        nextDelegateTo: next?.delegateTo ?? null,
+    };
 }