@specship/specship-win32-arm64 0.24.0 → 0.25.0

package/lib/dist/activation/steering.d.ts

@@ -17,19 +17,19 @@
  */
 export declare const STEERING_TEXT: string;
 /**
- * The haiku-tier template (LOWMODEL-DOC, REQ-LOWMODEL-002): small models
+ * The lite-tier template (LOWMODEL-DOC, REQ-LOWMODEL-002): small models
  * follow prescriptive templates far better than principles, and fan-out
  * (subagents) multiplies their cost and confusion. Kept under ~80 tokens
  * (REQ-LOWMODEL-002.A2).
  */
-export declare const STEERING_TEXT_HAIKU: string;
+export declare const STEERING_TEXT_LITE: string;
 /**
  * Decide whether to emit the steering line (REQ-STEER-002): silent unless the
  * project is initialized (`.specship/` exists at cwd), and silent when the
  * user opted out via `SPECSHIP_NO_STEERING=1`. Uninitialized projects and
  * opted-out users get zero prompt noise. Tier-aware (REQ-LOWMODEL-002):
- * haiku sessions get the prescriptive template; sonnet and frontier keep the
- * standard line.
+ * lite-tier sessions get the prescriptive template; standard and frontier keep
+ * the standard line.
  */
 export declare function buildSteeringNudge(cwd: string, env?: NodeJS.ProcessEnv, homedir?: string): string | null;
 //# sourceMappingURL=steering.d.ts.map

package/lib/dist/activation/steering.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"steering.d.ts","sourceRoot":"","sources":["../../src/activation/steering.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAOH;;;;GAIG;AACH,eAAO,MAAM,aAAa,QAKJ,CAAC;AAEvB;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,QAIqC,CAAC;AAEtE;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,MAAM,EACX,GAAG,GAAE,MAAM,CAAC,UAAwB,EACpC,OAAO,CAAC,EAAE,MAAM,GACf,MAAM,GAAG,IAAI,CAUf"}
+{"version":3,"file":"steering.d.ts","sourceRoot":"","sources":["../../src/activation/steering.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAOH;;;;GAIG;AACH,eAAO,MAAM,aAAa,QAKJ,CAAC;AAEvB;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,QAIsC,CAAC;AAEtE;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,MAAM,EACX,GAAG,GAAE,MAAM,CAAC,UAAwB,EACpC,OAAO,CAAC,EAAE,MAAM,GACf,MAAM,GAAG,IAAI,CAUf"}

package/lib/dist/activation/steering.js

@@ -45,7 +45,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.STEERING_TEXT_HAIKU = exports.STEERING_TEXT = void 0;
+exports.STEERING_TEXT_LITE = exports.STEERING_TEXT = void 0;
 exports.buildSteeringNudge = buildSteeringNudge;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -62,12 +62,12 @@ exports.STEERING_TEXT = 'This project has a SpecShip code-graph index. Before re
     'Treat the source it returns as already read; use Read/Grep only for content ' +
     'it did not return.';
 /**
- * The haiku-tier template (LOWMODEL-DOC, REQ-LOWMODEL-002): small models
+ * The lite-tier template (LOWMODEL-DOC, REQ-LOWMODEL-002): small models
  * follow prescriptive templates far better than principles, and fan-out
  * (subagents) multiplies their cost and confusion. Kept under ~80 tokens
  * (REQ-LOWMODEL-002.A2).
  */
-exports.STEERING_TEXT_HAIKU = 'This project has a SpecShip index. For any code question, call exactly: ' +
+exports.STEERING_TEXT_LITE = 'This project has a SpecShip index. For any code question, call exactly: ' +
     'mcp__specship__specship_explore with the symbol/file names from the question. ' +
     'ONE call, then answer from its output — the source it returns is already read. ' +
     'Do not spawn subagents. Do not Read/Grep files the tool returned.';
@@ -76,8 +76,8 @@ exports.STEERING_TEXT_HAIKU = 'This project has a SpecShip index. For any code q
  * project is initialized (`.specship/` exists at cwd), and silent when the
  * user opted out via `SPECSHIP_NO_STEERING=1`. Uninitialized projects and
  * opted-out users get zero prompt noise. Tier-aware (REQ-LOWMODEL-002):
- * haiku sessions get the prescriptive template; sonnet and frontier keep the
- * standard line.
+ * lite-tier sessions get the prescriptive template; standard and frontier keep
+ * the standard line.
  */
 function buildSteeringNudge(cwd, env = process.env, homedir) {
     // RUNSET-DOC: the opt-out resolves env > project .specship/settings.json >
@@ -91,6 +91,6 @@ function buildSteeringNudge(cwd, env = process.env, homedir) {
     catch {
         return null;
     }
-    return (0, model_context_1.detectModelTier)(cwd, env, homedir) === 'haiku' ? exports.STEERING_TEXT_HAIKU : exports.STEERING_TEXT;
+    return (0, model_context_1.detectModelTier)(cwd, env, homedir) === 'lite' ? exports.STEERING_TEXT_LITE : exports.STEERING_TEXT;
 }
 //# sourceMappingURL=steering.js.map

package/lib/dist/activation/steering.js.map

@@ -1 +1 @@
-{"version":3,"file":"steering.js","sourceRoot":"","sources":["../../src/activation/steering.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCH,gDAcC;AAnDD,uCAAyB;AACzB,2CAA6B;AAC7B,wDAAuD;AACvD,iEAA4D;AAE5D;;;;GAIG;AACU,QAAA,aAAa,GACxB,8EAA8E;IAC9E,4EAA4E;IAC5E,6EAA6E;IAC7E,8EAA8E;IAC9E,oBAAoB,CAAC;AAEvB;;;;;GAKG;AACU,QAAA,mBAAmB,GAC9B,0EAA0E;IAC1E,gFAAgF;IAChF,iFAAiF;IACjF,mEAAmE,CAAC;AAEtE;;;;;;;GAOG;AACH,SAAgB,kBAAkB,CAChC,GAAW,EACX,MAAyB,OAAO,CAAC,GAAG,EACpC,OAAgB;IAEhB,2EAA2E;IAC3E,qEAAqE;IACrE,IAAI,IAAA,iCAAc,EAAC,sBAAsB,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,CAAC,KAAK,GAAG;QAAE,OAAO,IAAI,CAAC;IACnF,IAAI,CAAC;QACH,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,WAAW,EAAE;YAAE,OAAO,IAAI,CAAC;IAC3E,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,IAAA,+BAAe,EAAC,GAAG,EAAE,GAAG,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,2BAAmB,CAAC,CAAC,CAAC,qBAAa,CAAC;AAC9F,CAAC"}
+{"version":3,"file":"steering.js","sourceRoot":"","sources":["../../src/activation/steering.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCH,gDAcC;AAnDD,uCAAyB;AACzB,2CAA6B;AAC7B,wDAAuD;AACvD,iEAA4D;AAE5D;;;;GAIG;AACU,QAAA,aAAa,GACxB,8EAA8E;IAC9E,4EAA4E;IAC5E,6EAA6E;IAC7E,8EAA8E;IAC9E,oBAAoB,CAAC;AAEvB;;;;;GAKG;AACU,QAAA,kBAAkB,GAC7B,0EAA0E;IAC1E,gFAAgF;IAChF,iFAAiF;IACjF,mEAAmE,CAAC;AAEtE;;;;;;;GAOG;AACH,SAAgB,kBAAkB,CAChC,GAAW,EACX,MAAyB,OAAO,CAAC,GAAG,EACpC,OAAgB;IAEhB,2EAA2E;IAC3E,qEAAqE;IACrE,IAAI,IAAA,iCAAc,EAAC,sBAAsB,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,CAAC,KAAK,GAAG;QAAE,OAAO,IAAI,CAAC;IACnF,IAAI,CAAC;QACH,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,WAAW,EAAE;YAAE,OAAO,IAAI,CAAC;IAC3E,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,IAAA,+BAAe,EAAC,GAAG,EAAE,GAAG,EAAE,OAAO,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,0BAAkB,CAAC,CAAC,CAAC,qBAAa,CAAC;AAC5F,CAAC"}

package/lib/dist/bin/specship.js

@@ -925,6 +925,18 @@ function main() {
                     details.push(`Removed: ${result.filesRemoved}`);
                 clack.log.info(`${details.join(', ')} ${(0, glyphs_1.getGlyphs)().dash} ${formatNumber(result.nodesUpdated)} nodes in ${formatDuration(result.durationMs)}`);
             }
+            // Spec parse problems from the sync's spec pass (REQ-REVINT-002.A2) —
+            // silent before, so a bare-path link bullet produced no edge and no word.
+            const specErrors = result.specErrors ?? 0;
+            const specWarnings = result.specWarnings ?? 0;
+            if (specErrors > 0 || specWarnings > 0) {
+                const parts = [];
+                if (specErrors > 0)
+                    parts.push(`${specErrors} error${specErrors === 1 ? '' : 's'}`);
+                if (specWarnings > 0)
+                    parts.push(`${specWarnings} warning${specWarnings === 1 ? '' : 's'}`);
+                clack.log.warn(`Spec parse: ${parts.join(', ')}`);
+            }
             pushDriftNotices(result);
             await pushJiraDriftComments(cg, result);
             await pushJiraAutoPublish(result);
@@ -1384,7 +1396,7 @@ function main() {
                 }
                 else {
                     info(`Captured as proposal ${p.contentHash.slice(0, 12)} (${p.state}): ${p.title}`);
-                    info('Review and apply it from the dashboard Improvements page (preview-diff → confirm).');
+                    info('Review the open proposals with `specship reflect` — nothing lands until you apply it.');
                 }
                 cg.destroy();
                 return;
@@ -1420,7 +1432,7 @@ function main() {
                 console.log(chalk.dim(`      ${p.body}`));
                 console.log();
             }
-            info('Review and apply proposals from the dashboard Improvements page (preview-diff → confirm).');
+            info('These are proposals only — nothing is written until you apply one.');
             cg.destroy();
         }
         catch (err) {
@@ -1472,7 +1484,7 @@ function main() {
             else {
                 info(`Captured lesson as proposal ${p.contentHash.slice(0, 12)} (${p.state}): ${p.title}`);
                 info(`Target: ${p.targetKind === 'claude_md' ? 'project CLAUDE.md' : 'portable ~/.claude memory note'} — nothing written yet.`);
-                info('Review + apply from the dashboard Improvements page (preview-diff → confirm), or `specship reflect`.');
+                info('Review with `specship reflect`; manage applied memory rules with `specship memory list`.');
             }
             cg.destroy();
         }
@@ -1720,6 +1732,159 @@ function main() {
             process.exit(1);
         }
     });
+    /**
+     * specship coverage [spec_id]
+     *
+     * The spec coverage rollup (REQ-VSTATE-006): per requirement and per acceptance
+     * criterion, how much of the spec has TEST evidence — `implements` links never
+     * count. Deterministic and cheap, which is what lets the implement workflow's
+     * human gate quote a real number instead of an LLM's count (REQ-VSTATE-005.A2).
+     */
+    program
+        .command('coverage [spec]')
+        .description('Show spec test-coverage: per requirement and criterion, tests-link state and verdict')
+        .option('-p, --path <path>', 'Project path')
+        .option('-j, --json', 'Output as JSON')
+        .option('--line', 'Print only the one-line "N of M acceptance criteria …" summary')
+        .action(async (specArg, options) => {
+        const projectPath = resolveProjectPath(options.path);
+        try {
+            if (!(0, directory_1.isInitialized)(projectPath)) {
+                error(`SpecShip not initialized in ${projectPath}`);
+                process.exit(1);
+            }
+            const { default: SpecShip, formatCoverageLine } = await loadSpecShip();
+            const cg = await SpecShip.open(projectPath);
+            const report = cg.getSpecCoverage(specArg);
+            if (options.json) {
+                console.log(JSON.stringify(report, null, 2));
+                cg.destroy();
+                return;
+            }
+            if (options.line) {
+                console.log(formatCoverageLine(report));
+                cg.destroy();
+                return;
+            }
+            if (report.requirements.length === 0) {
+                info(specArg
+                    ? `No requirements under "${specArg}" — nothing to report.`
+                    : 'No requirements indexed yet.');
+                cg.destroy();
+                return;
+            }
+            const mark = {
+                verified: chalk.green('✔'),
+                tested: chalk.yellow('~'),
+                untested: chalk.dim('·'),
+                broken: chalk.red('✗'),
+            };
+            for (const req of report.requirements) {
+                console.log(`${mark[req.verdict]} ${chalk.bold(req.specId)} ${chalk.dim(req.verdict)} — ${req.title}`);
+                for (const c of req.criteria) {
+                    console.log(`    ${mark[c.verdict]} ${c.specId} ${chalk.dim(`${c.verdict} · implements:${c.implementsLinks.count} tests:${c.testsLinks.count}`)}`);
+                }
+            }
+            console.log();
+            console.log(formatCoverageLine(report));
+            cg.destroy();
+        }
+        catch (err) {
+            error(`coverage failed: ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
+    });
+    /**
+     * specship lint [paths...]
+     *
+     * Spec-authoring lint (AUTHG-DOC). A thin registration: all rules, rendering
+     * and the exit code live in `src/spec-lint/lint.ts` (`runLintCli` returns the
+     * text and the code rather than printing or exiting, which is what makes it
+     * testable). Needs no index — it reads the files directly, so it runs in a
+     * fresh checkout and in CI before anything has been indexed.
+     */
+    program
+        .command('lint [paths...]')
+        .description('Lint spec files for authoring problems (exits non-zero on an error finding)')
+        .option('-p, --path <path>', 'Project path (paths are resolved against it; defaults to specs/)')
+        .option('-j, --json', 'Output as JSON')
+        .action(async (paths, options) => {
+        const projectRoot = resolveProjectPath(options.path);
+        try {
+            const { runLintCli } = await Promise.resolve().then(() => __importStar(require('../spec-lint/lint')));
+            const { output, exitCode } = runLintCli([...(paths ?? []), ...(options.json ? ['--json'] : [])], { projectRoot });
+            console.log(output);
+            if (exitCode !== 0)
+                process.exit(exitCode);
+        }
+        catch (err) {
+            error(`lint failed: ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
+    });
+    /**
+     * specship verify --report <file>
+     *
+     * Derive verification from a REAL test run (REQ-VSTATE-004): read a vitest JSON
+     * report, match reported cases to `tests` links by file + test title, and
+     * promote/demote those links. Replaces "an agent read the log and said it
+     * passed" with something auditable back to a specific run.
+     *
+     * A malformed report exits non-zero having changed nothing (A4).
+     */
+    program
+        .command('verify')
+        .description('Ingest a test report (vitest JSON) and promote/demote spec test links from it')
+        .requiredOption('--report <file>', 'Path to the test report (vitest `--reporter=json` output)')
+        .option('-p, --path <path>', 'Project path')
+        .option('-j, --json', 'Output as JSON')
+        .option('--run-id <id>', 'Identifier recorded as the run behind the verdict')
+        .action(async (options) => {
+        const projectPath = resolveProjectPath(options.path);
+        try {
+            if (!(0, directory_1.isInitialized)(projectPath)) {
+                error(`SpecShip not initialized in ${projectPath}`);
+                process.exit(1);
+            }
+            const { default: SpecShip } = await loadSpecShip();
+            const cg = await SpecShip.open(projectPath);
+            let result;
+            try {
+                result = cg.verifyFromReport(options.report, { runId: options.runId });
+            }
+            catch (err) {
+                cg.destroy();
+                error(`verify failed: ${err instanceof Error ? err.message : String(err)}`);
+                process.exit(1);
+                return;
+            }
+            if (options.json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                success(`Read ${result.cases} test case(s) from ${result.reportPath} (run ${result.runId}).`);
+                for (const p of result.promoted) {
+                    console.log(`  ${chalk.green('✔')} ${p.specId} ${chalk.dim(`${p.from} → verified`)} — ${p.titles[0] ?? ''}`);
+                }
+                for (const d of result.demoted) {
+                    console.log(`  ${chalk.red('✗')} ${d.specId} ${chalk.dim(`${d.from} → broken`)} — ${d.titles[0] ?? ''}`);
+                }
+                console.log();
+                info(`${result.promoted.length} verified, ${result.demoted.length} broken, ${result.unchanged} unchanged, ${result.unmatched} unmatched.`);
+                // Unmatched cases are reported, never silently dropped (A3).
+                for (const u of result.unmatchedSample)
+                    console.log(chalk.dim(`    unmatched: ${u}`));
+                if (result.unmatched > result.unmatchedSample.length) {
+                    console.log(chalk.dim(`    …and ${result.unmatched - result.unmatchedSample.length} more`));
+                }
+            }
+            cg.destroy();
+        }
+        catch (err) {
+            error(`verify failed: ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
+    });
     /**
      * specship fitness
      *
@@ -1800,6 +1965,7 @@ function main() {
         .option('-j, --json', 'Output as JSON')
         .option('--strict', 'Treat every check as gating for this run only (nothing read from or written to config)')
         .option('--enable-gate <checks...>', 'Persist gating for the named checks into specship.config.json, then run the gate')
+        .option('--since <ref>', 'Evaluate only requirements whose links or spec files touch files changed since <ref> (drift + behaviour; fitness and maintainability stay repo-global)')
         .action(async (pathArg, options) => {
         const projectPath = resolveProjectPath(pathArg);
         try {
@@ -1808,6 +1974,21 @@ function main() {
                 process.exit(1);
             }
             const enforce = await Promise.resolve().then(() => __importStar(require('../enforce/enforce')));
+            // --since narrows the link-scoped checks (REQ-AUTHG-006.A1). An
+            // unresolvable ref exits non-zero here: falling back to a full-repo run
+            // would answer a question the caller did not ask and hide the typo
+            // (A3).
+            let scope;
+            if (options.since) {
+                const { changedFilesSince } = await Promise.resolve().then(() => __importStar(require('../enforce/changed-files')));
+                try {
+                    scope = { changedFiles: changedFilesSince(projectPath, options.since), since: options.since };
+                }
+                catch (err) {
+                    error(err instanceof Error ? err.message : String(err));
+                    process.exit(1);
+                }
+            }
             // --enable-gate writes the opt-in config, then falls through to a
             // normal run so the user immediately sees the gate with teeth
             // (REQ-ENFORCE-004.A1).
@@ -1825,17 +2006,24 @@ function main() {
             const { default: SpecShip } = await loadSpecShip();
             const cg = await SpecShip.open(projectPath);
             // --strict gates everything for this run only (REQ-ENFORCE-004.A2).
-            const r = options.strict ? cg.getEnforce(enforce.strictEnforceConfig()) : cg.getEnforce();
+            const r = options.strict
+                ? cg.getEnforce(enforce.strictEnforceConfig(), scope)
+                : cg.getEnforce(undefined, scope);
             if (options.json) {
                 console.log(JSON.stringify(r, null, 2));
                 cg.destroy();
                 process.exit(r.passed ? 0 : 1);
             }
             console.log(chalk.bold('\nEnforcement gate\n'));
+            if (scope) {
+                console.log(chalk.dim(`  scoped to ${scope.changedFiles.length} file(s) changed since ${scope.since}` +
+                    ' — drift and behaviour are link-scoped; fitness and maintainability are repo-global analyses and ran unscoped.\n'));
+            }
             for (const c of r.checks) {
                 const tag = c.gating ? chalk.dim('[gating]') : chalk.dim('[advisory]');
                 const mark = c.passed ? chalk.green('✓') : (c.gating ? chalk.red('✗') : chalk.yellow('•'));
-                console.log(`  ${mark} ${c.check.padEnd(16)} ${tag} ${c.passed ? 'pass' : `${c.findings.length} finding(s)`}`);
+                const reach = scope ? chalk.dim(c.scoped ? ' [since]' : ' [repo-wide]') : '';
+                console.log(`  ${mark} ${c.check.padEnd(16)} ${tag}${reach} ${c.passed ? 'pass' : `${c.findings.length} finding(s)`}`);
                 if (!c.passed)
                     for (const f of c.findings.slice(0, 8))
                         console.log(chalk.dim(`        ${f}`));
@@ -2458,16 +2646,16 @@ function main() {
         .command('install')
         .description('Install specship MCP server into Claude Code')
         .option('-l, --location <where>', 'Install location: "global" or "local". Default: prompt (local)')
-        .option('-y, --yes', 'Non-interactive: defaults to --location=local, auto-allow on')
-        .option('--no-permissions', 'Skip writing the auto-allow permissions list')
+        .option('-y, --yes', 'Non-interactive: defaults to --location=local (the only question an interactive install asks)')
+        .option('--no-permissions', 'Skip writing the auto-allow permissions list (written by default)')
         .option('--sdd', '(default) Install the spec-driven-development governance tier (spec/authoring/review/design commands + the spec-author nudge hook)')
         .option('--no-sdd', 'Skip the governance tier — retrieval-only install (the pre-0.18 default)')
         .option('--path <repo>', 'Target repo to wire and initialize (default: current directory). Project-local files and the .specship index land there')
         .option('--with-jira', 'Enable the optional JIRA integration (talks to your Atlassian instance; off by default — the core install is 100% local)')
         .option('--with-designer', 'Enable the optional Designer integration (EXPERIMENTAL — drives claude.ai/design via a debug Chrome session and may break without notice; off by default)')
-        .option('--statusline', 'Wire the SpecShip status-line segment into Claude (skips the prompt; never overwrites an existing status line)')
-        .option('--skip-statusline', 'Do not add the status-line segment (skips the prompt)')
-        .option('--skip-index', 'Do not offer to index the current project (an explicit opt-out for automation)')
+        .option('--statusline', '(default) Wire the SpecShip status-line segment into Claude; never overwrites an existing status line')
+        .option('--skip-statusline', 'Do not add the status-line segment (it is added by default)')
+        .option('--skip-index', 'Do not index the current project (it is indexed by default)')
         .option('--print-config', 'Print the MCP config snippet and exit (no file writes). Claude Code by default; `--target gemini` prints the Gemini CLI settings snippet')
         // -t/--target SELECTS the agents to wire (GEMINI-TARGET-DOC, REQ-GEMINI-002)
         // and also picks the snippet --print-config prints. The legacy spellings
@@ -2509,30 +2697,23 @@ function main() {
         }
         try {
             // Commander's `--no-permissions` makes `opts.permissions === false`;
-            // omitting the flag leaves it `true` (the positive-form default).
-            // We MUST treat the default-true as "user did not override — let
-            // the orchestrator prompt" and only forward an explicit `false`
-            // (or `true` when --yes implies it). Otherwise the auto-allow
-            // prompt is silently skipped on every interactive run.
+            // omitting the flag leaves it `true` (the positive-form default), which
+            // we must forward as `undefined` — "user did not override" — so the
+            // installer can tell a default from an explicit choice and name the
+            // defaults in its summary (REQ-SLIM-003.A2).
             const explicitNoPermissions = opts.permissions === false;
-            const autoAllow = explicitNoPermissions
+            const autoAllow = explicitNoPermissions ? false : undefined;
+            // Status line: default ON, never prompted (REQ-SLIM-003.A1).
+            // `--skip-statusline` is the opt-out; `--statusline` is now a no-op
+            // affirmation kept for compatibility (REQ-SLIM-003.A3). Distinct flag
+            // names (rather than `--no-statusline`) dodge commander's `--no-*`
+            // default-true coupling.
+            const statusLine = opts.skipStatusline
                 ? false
-                : opts.yes
+                : opts.statusline
                     ? true
                     : undefined;
-            // Status-line opt-in: `--statusline` forces on, `--skip-statusline`
-            // forces off (both skip the prompt); neither ⇒ undefined ⇒ ask
-            // interactively (default no). Distinct flag names dodge commander's
-            // `--no-*` default-true coupling that would auto-install.
-            const statusLine = opts.statusline
-                ? true
-                : opts.skipStatusline
-                    ? false
-                    : undefined;
-            // The governance tier is opt-in (INSTALL-WEDGE-DOC): `--sdd` makes
-            // `opts.sdd === true`; omitting it leaves it undefined → retrieval-only.
-            // Forward `true` only when the user explicitly opted in.
-            await runInstallerWithOptions({
+            const outcome = await runInstallerWithOptions({
                 target: opts.target,
                 location: opts.location,
                 autoAllow,
@@ -2544,8 +2725,10 @@ function main() {
                 statusLine,
                 yes: opts.yes,
             });
-            // Offer to index the current project (REQ-HANDSHAKE-004) before the smoke
-            // check, so an accepted index is reflected by the index-queryable item.
+            // Index the current project (REQ-HANDSHAKE-004) before the smoke check,
+            // so the new index is reflected by the index-queryable item. Not a
+            // question any more (REQ-SLIM-003.A1) — `--skip-index` opts out, and the
+            // summary below names the default.
             const cwd = process.cwd();
             const { decideInstallInit } = await Promise.resolve().then(() => __importStar(require('../installer/init-offer')));
             const { isGitRepo } = await Promise.resolve().then(() => __importStar(require('../sync/git-hooks')));
@@ -2555,14 +2738,7 @@ function main() {
                 yes: opts.yes === true,
                 skipIndex: opts.skipIndex === true,
             });
-            let doIndex = initDecision === 'auto-index';
-            if (initDecision === 'offer') {
-                const clack = await importESM('@clack/prompts');
-                const ans = await clack.confirm({
-                    message: `Index this project (${cwd}) now, so Claude can explore it?`,
-                });
-                doIndex = ans === true; // a cancel (symbol) or "no" both decline (REQ-HANDSHAKE-004.A2)
-            }
+            const doIndex = initDecision === 'auto-index';
             if (doIndex) {
                 console.log();
                 info(`Indexing ${cwd} …`);
@@ -2574,6 +2750,22 @@ function main() {
                     warn(`Indexing failed (run \`specship init -i\` later): ${e instanceof Error ? e.message : String(e)}`);
                 }
             }
+            // Name the defaulted indexing decision the same way the installer names
+            // its own (REQ-SLIM-003.A2). The installer already printed this line when
+            // a local install built the index itself, so it is never doubled.
+            if (doIndex && !outcome?.indexed) {
+                const { describeInstallDefaults } = await Promise.resolve().then(() => __importStar(require('../installer/install-defaults')));
+                for (const line of describeInstallDefaults({
+                    statusLine: 'skipped',
+                    statusLineDefaulted: false,
+                    autoAllow: false,
+                    autoAllowDefaulted: false,
+                    index: 'indexed',
+                    indexDefaulted: true,
+                })) {
+                    info(line);
+                }
+            }
             // Post-install smoke check (REQ-HANDSHAKE-002). Advisory: report failing
             // items but never exit non-zero (REQ-HANDSHAKE-002.A4), so a provisioning
             // script is never broken by it — the gating equivalent is `specship doctor`.