@mjasnikovs/pi-task 0.18.12 → 0.18.14

package/dist/config/config.d.ts

@@ -30,6 +30,23 @@ export interface PiTaskConfig {
      * DEFAULT `exa` so search works out of the box with zero configuration.
      */
     searchProvider: SearchProvider;
+    /**
+     * Absolute entry-point paths of host pi extensions to load into every child
+     * pi session via explicit `-e` flags (GitHub issue #4: a provider registered
+     * by an extension — e.g. pi-lmstudio — otherwise doesn't exist in children,
+     * which then can't resolve the default model and demand OAuth/API keys).
+     * Children keep `--no-extensions`, so discovery stays off and ONLY these
+     * load — the whitelist is strictly additive. Entries whose file no longer
+     * exists (extension uninstalled) are skipped at spawn time, never fatal.
+     * DEFAULT empty: child isolation is unchanged until the user opts in via
+     * /task-config, which enumerates the currently installed extensions.
+     */
+    extensionWhitelist: string[];
 }
+/**
+ * A hand-edited config can hold anything; keep only string entries so a stray
+ * object/number can't reach the child argv as `-e [object Object]`.
+ */
+export declare function sanitizeExtensionWhitelist(value: unknown): string[];
 export declare function getConfig(): PiTaskConfig;
 export declare function saveConfig(config: PiTaskConfig): Promise<void>;

package/dist/config/config.js

@@ -14,8 +14,18 @@ const DEFAULTS = {
     // ON: the F10 live A/B showed no answer-quality regression (fidelity 3/3, quality
     // 3/3, 0 collisions; ~14.5s of repeated docs lookups collapse to 0ms on a hit).
     researchCache: true,
-    searchProvider: 'exa'
+    searchProvider: 'exa',
+    extensionWhitelist: []
 };
+/**
+ * A hand-edited config can hold anything; keep only string entries so a stray
+ * object/number can't reach the child argv as `-e [object Object]`.
+ */
+export function sanitizeExtensionWhitelist(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((p) => typeof p === 'string' && p.trim().length > 0);
+}
 const CONFIG_PATH = path.join(os.homedir(), '.config', 'pi-task', 'config.json');
 const _g = globalThis;
 if (!_g.__piTaskConfig) {
@@ -32,6 +42,7 @@ if (!G.loaded) {
         // into the dispatch switch — fall back to the default.
         if (!isSearchProvider(parsed.searchProvider))
             delete parsed.searchProvider;
+        parsed.extensionWhitelist = sanitizeExtensionWhitelist(parsed.extensionWhitelist);
         G.config = { ...DEFAULTS, ...parsed };
     }
     catch {

package/dist/config/extension-list.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Enumerates the host's installed pi extensions for the /task-config whitelist
+ * (GitHub issue #4) using pi's OWN resolver — the same DefaultPackageManager
+ * the host runtime discovers extensions with — so the menu always mirrors what
+ * `pi list`/discovery would load: install a package and it appears, uninstall
+ * it and it vanishes (a stale whitelist entry is then skipped at spawn time by
+ * extensionArgs' existence filter, never fatal).
+ */
+export interface InstalledExtension {
+    /** Absolute entry-point path — the whitelist identity AND the `-e` value. */
+    path: string;
+    /** Short display name: package name for package sources, file stem for loose files. */
+    label: string;
+    /** Provenance shown in the menu, e.g. "npm:pi-lmstudio (user)" or "discovered (user)". */
+    origin: string;
+}
+/**
+ * pi-task's own package root. Anything resolve() reports under it is pi-task
+ * itself (`dist/index.js` shows up as a discovered extension) and MUST be
+ * excluded: whitelisting pi-task into its own children would recursively boot
+ * the remote server and re-register every command in each child.
+ */
+export declare function selfPackageRoot(fromDir?: string): string;
+/** Display label for a resolved extension entry. */
+export declare function extensionLabel(entryPath: string, source: string): string;
+export interface ListInstalledOptions {
+    cwd: string;
+    /** Override for tests; defaults to the host's real agent dir (~/.pi/agent). */
+    agentDir?: string;
+    /** Override for tests; defaults to pi-task's own package root. */
+    selfRoot?: string;
+}
+/**
+ * List every extension the host pi would load, excluding pi-task itself.
+ * Only enabled entries are offered: an extension the user disabled in
+ * `pi config` shouldn't be sneaked back in through a child whitelist.
+ * Errors (unreadable settings, missing package dirs) surface as an empty
+ * list at the caller — the menu then simply shows no extension toggles.
+ */
+export declare function listInstalledExtensions(opts: ListInstalledOptions): Promise<InstalledExtension[]>;

package/dist/config/extension-list.js

@@ -0,0 +1,66 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { DefaultPackageManager, SettingsManager, getAgentDir } from '@earendil-works/pi-coding-agent';
+/**
+ * pi-task's own package root. Anything resolve() reports under it is pi-task
+ * itself (`dist/index.js` shows up as a discovered extension) and MUST be
+ * excluded: whitelisting pi-task into its own children would recursively boot
+ * the remote server and re-register every command in each child.
+ */
+export function selfPackageRoot(fromDir) {
+    let dir = fromDir ?? path.dirname(fileURLToPath(import.meta.url));
+    for (;;) {
+        if (fs.existsSync(path.join(dir, 'package.json')))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return dir;
+        dir = parent;
+    }
+}
+function isUnder(p, root) {
+    const rel = path.relative(root, p);
+    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+/** Display label for a resolved extension entry. */
+export function extensionLabel(entryPath, source) {
+    // Package sources keep their identity ("npm:pi-lmstudio" → "pi-lmstudio");
+    // discovered/local files read best as the file or directory stem.
+    if (source.includes(':'))
+        return source.slice(source.indexOf(':') + 1);
+    const base = path.basename(entryPath).replace(/\.(ts|js|mts|mjs|cts|cjs)$/, '');
+    return base === 'index' ? path.basename(path.dirname(entryPath)) : base;
+}
+/**
+ * List every extension the host pi would load, excluding pi-task itself.
+ * Only enabled entries are offered: an extension the user disabled in
+ * `pi config` shouldn't be sneaked back in through a child whitelist.
+ * Errors (unreadable settings, missing package dirs) surface as an empty
+ * list at the caller — the menu then simply shows no extension toggles.
+ */
+export async function listInstalledExtensions(opts) {
+    const agentDir = opts.agentDir ?? getAgentDir();
+    const selfRoot = opts.selfRoot ?? selfPackageRoot();
+    const settingsManager = SettingsManager.create(opts.cwd, agentDir);
+    const pm = new DefaultPackageManager({ cwd: opts.cwd, agentDir, settingsManager });
+    // "skip": a package in settings whose install dir is missing must not
+    // trigger an interactive install prompt from inside a config menu.
+    const resolved = await pm.resolve(() => Promise.resolve('skip'));
+    const out = [];
+    for (const r of resolved.extensions) {
+        if (!r.enabled)
+            continue;
+        const abs = path.resolve(r.path);
+        if (isUnder(abs, selfRoot))
+            continue;
+        out.push({
+            path: abs,
+            label: extensionLabel(abs, r.metadata.source),
+            origin: r.metadata.source === 'auto' ?
+                `discovered (${r.metadata.scope})`
+                : `${r.metadata.source} (${r.metadata.scope})`
+        });
+    }
+    return out;
+}

package/dist/config/register.d.ts

@@ -1,2 +1,12 @@
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { type InstalledExtension } from './extension-list.js';
+export declare function extensionItems(extensions: InstalledExtension[], whitelist: readonly string[]): {
+    id: string;
+    label: string;
+    description: string;
+    currentValue: string;
+    values: string[];
+}[];
+/** Apply an extension toggle to the config's whitelist (idempotent both ways). */
+export declare function applyExtensionToggle(whitelist: readonly string[], entryPath: string, on: boolean): string[];
 export declare function registerConfig(pi: ExtensionAPI): void;

package/dist/config/register.js

@@ -2,6 +2,7 @@ import { SettingsList, visibleWidth } from '@earendil-works/pi-tui';
 import { registerBridgeCommand } from '../remote/bridge.js';
 import { SEARCH_PROVIDERS, SEARCH_PROVIDER_LABELS, providerForLabel } from '../workers/search-types.js';
 import { getConfig, saveConfig } from './config.js';
+import { listInstalledExtensions } from './extension-list.js';
 const CONFIG_TITLE = 'pi-task settings';
 /**
  * Frames a child component (the settings list) in a rounded border with a title
@@ -104,6 +105,29 @@ function displayValue(cfg, id, isEnum) {
         return String(cfg[id]);
     return cfg[id] ? 'on' : 'off';
 }
+/**
+ * One /task-config toggle per installed host extension (GitHub issue #4).
+ * The id carries the entry path behind a prefix so the shared onChange handler
+ * can tell an extension toggle from a PiTaskConfig field.
+ */
+const EXT_ID_PREFIX = 'ext:';
+export function extensionItems(extensions, whitelist) {
+    return extensions.map(e => ({
+        id: EXT_ID_PREFIX + e.path,
+        label: `ext: ${e.label}`,
+        description: `Also load this extension (${e.origin}) in pi-task child sessions — needed when it `
+            + 'registers the model provider the children must use (e.g. pi-lmstudio). Children '
+            + 'otherwise run with extensions off; whitelist only provider-type extensions you '
+            + `trust, since children also get its tools and hooks. ${e.path}`,
+        currentValue: whitelist.includes(e.path) ? 'on' : 'off',
+        values: ['on', 'off']
+    }));
+}
+/** Apply an extension toggle to the config's whitelist (idempotent both ways). */
+export function applyExtensionToggle(whitelist, entryPath, on) {
+    const rest = whitelist.filter(p => p !== entryPath);
+    return on ? [...rest, entryPath] : rest;
+}
 function makeTheme(theme) {
     return {
         label: (text, selected) => (selected ? theme.fg('accent', text) : text),
@@ -114,23 +138,37 @@ function makeTheme(theme) {
     };
 }
 async function handleTaskConfig(_args, ctx) {
-    const cfg = { ...getConfig() };
+    const cfg = { ...getConfig(), extensionWhitelist: [...getConfig().extensionWhitelist] };
+    // Enumerated live at open so an installed extension appears and an
+    // uninstalled one vanishes without pi-task doing any bookkeeping. A failed
+    // enumeration only costs the extension toggles, never the whole menu.
+    const installed = await listInstalledExtensions({ cwd: ctx.cwd }).catch(() => []);
     if (ctx.mode !== 'tui') {
         const lines = ITEMS.map(({ id, label, values }) => `${label.padEnd(22)} ${displayValue(cfg, id, Boolean(values))}`);
+        for (const e of installed) {
+            const state = cfg.extensionWhitelist.includes(e.path) ? 'on' : 'off';
+            lines.push(`${('ext: ' + e.label).padEnd(22)} ${state}`);
+        }
         ctx.ui.notify(lines.join('  |  '), 'info');
         return;
     }
     await ctx.ui.custom((_tui, theme, _kb, done) => {
         const listTheme = makeTheme(theme);
-        const items = ITEMS.map(({ id, label, description, values }) => ({
-            id,
-            label,
-            description,
-            currentValue: displayValue(cfg, id, Boolean(values)),
-            values: values ?? ['on', 'off']
-        }));
+        const items = [
+            ...ITEMS.map(({ id, label, description, values }) => ({
+                id: id,
+                label,
+                description,
+                currentValue: displayValue(cfg, id, Boolean(values)),
+                values: values ?? ['on', 'off']
+            })),
+            ...extensionItems(installed, cfg.extensionWhitelist)
+        ];
         const list = new SettingsList(items, 10, listTheme, (id, newValue) => {
-            if (id === 'searchProvider') {
+            if (id.startsWith(EXT_ID_PREFIX)) {
+                cfg.extensionWhitelist = applyExtensionToggle(cfg.extensionWhitelist, id.slice(EXT_ID_PREFIX.length), newValue === 'on');
+            }
+            else if (id === 'searchProvider') {
                 const provider = providerForLabel(newValue);
                 if (provider)
                     cfg.searchProvider = provider;
@@ -146,7 +184,8 @@ async function handleTaskConfig(_args, ctx) {
 }
 export function registerConfig(pi) {
     registerBridgeCommand(pi, 'task-config', {
-        description: 'Configure pi-task settings (remote, compress reasoning, auto-commit, orientation, enforce guidelines).',
+        description: 'Configure pi-task settings (remote, compress reasoning, auto-commit, orientation, '
+            + 'enforce guidelines, extension whitelist for child sessions).',
         handler: handleTaskConfig
     });
 }

package/dist/shared/child-extensions.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Extension whitelist → child argv (GitHub issue #4).
+ *
+ * Child pi sessions run with `--no-extensions`, so a provider registered by a
+ * host extension (e.g. pi-lmstudio) doesn't exist in them — the child can't
+ * resolve the default model and demands OAuth/API keys. pi's `--no-extensions`
+ * explicitly preserves explicit `-e <path>` loads (only discovery is disabled),
+ * so injecting the user's whitelisted entry paths restores the provider while
+ * keeping every non-whitelisted extension out. Same mechanism pi-task already
+ * uses for its own worker-tool extensions (see runWorker's `extensions` input).
+ */
+/**
+ * Map whitelisted entry paths to `-e` argv pairs. Pure given `exists`.
+ *
+ * A path whose file is gone (extension uninstalled since it was whitelisted)
+ * is skipped silently: pi itself would record "Extension path does not exist"
+ * as a load ERROR, and a stale toggle must never break every child spawn.
+ * Duplicates collapse so a path can't be loaded twice.
+ */
+export declare function extensionArgs(paths: readonly string[], exists?: (p: string) => boolean): string[];
+/**
+ * The base argv every child pi invocation starts from: internal worker
+ * extensions (verbatim — they always exist, shipped in dist), then the user's
+ * whitelisted extensions (existence-filtered, deduped against the internal
+ * ones), then CHILD_BASE_ARGS. Computed per spawn, not at module load, so a
+ * /task-config toggle takes effect for the next child without a restart.
+ */
+export declare function childBaseArgs(internalExtensions?: readonly string[]): string[];

package/dist/shared/child-extensions.js

@@ -0,0 +1,47 @@
+import * as fs from 'node:fs';
+import { CHILD_BASE_ARGS } from './child-process.js';
+import { getConfig } from '../config/config.js';
+/**
+ * Extension whitelist → child argv (GitHub issue #4).
+ *
+ * Child pi sessions run with `--no-extensions`, so a provider registered by a
+ * host extension (e.g. pi-lmstudio) doesn't exist in them — the child can't
+ * resolve the default model and demands OAuth/API keys. pi's `--no-extensions`
+ * explicitly preserves explicit `-e <path>` loads (only discovery is disabled),
+ * so injecting the user's whitelisted entry paths restores the provider while
+ * keeping every non-whitelisted extension out. Same mechanism pi-task already
+ * uses for its own worker-tool extensions (see runWorker's `extensions` input).
+ */
+/**
+ * Map whitelisted entry paths to `-e` argv pairs. Pure given `exists`.
+ *
+ * A path whose file is gone (extension uninstalled since it was whitelisted)
+ * is skipped silently: pi itself would record "Extension path does not exist"
+ * as a load ERROR, and a stale toggle must never break every child spawn.
+ * Duplicates collapse so a path can't be loaded twice.
+ */
+export function extensionArgs(paths, exists = fs.existsSync) {
+    const seen = new Set();
+    const args = [];
+    for (const p of paths) {
+        if (typeof p !== 'string' || p.trim().length === 0 || seen.has(p))
+            continue;
+        seen.add(p);
+        if (!exists(p))
+            continue;
+        args.push('-e', p);
+    }
+    return args;
+}
+/**
+ * The base argv every child pi invocation starts from: internal worker
+ * extensions (verbatim — they always exist, shipped in dist), then the user's
+ * whitelisted extensions (existence-filtered, deduped against the internal
+ * ones), then CHILD_BASE_ARGS. Computed per spawn, not at module load, so a
+ * /task-config toggle takes effect for the next child without a restart.
+ */
+export function childBaseArgs(internalExtensions = []) {
+    const internal = internalExtensions.flatMap(e => ['-e', e]);
+    const whitelisted = extensionArgs(getConfig().extensionWhitelist.filter(p => !internalExtensions.includes(p)));
+    return [...internal, ...whitelisted, ...CHILD_BASE_ARGS];
+}

package/dist/shared/child-process.d.ts

@@ -90,6 +90,17 @@ export interface RunChildJsonEventsOptions {
     onLine?: (line: string) => void;
     onContextUsage?: (snapshot: ContextSnapshot) => void;
     onToolCall?: (call: ToolCall) => LoopHit | null;
+    /**
+     * Fires when a tool call finishes, carrying its RESULT (mx5 run 10 item 6: the
+     * verify debug log recorded the `bash:` command but never its output, so "verify
+     * claimed curl PASS on a server that cannot serve" was undecidable from the log).
+     * Text is the tool's combined output; `isError` distinguishes a failed call.
+     */
+    onToolResult?: (result: {
+        name: string;
+        isError: boolean;
+        text: string;
+    }) => void;
     onFirstByte?: () => void;
     /**
      * Dead-backend stall guard (mx5 run 7: model server died mid-child, the

package/dist/shared/child-process.js

@@ -159,9 +159,27 @@ export class JsonEventSink {
                 if (hit)
                     this.onLoopKill();
             }
+            return;
+        }
+        if (t === 'tool_execution_end' && opts.onToolResult) {
+            const tn = typeof evt.toolName === 'string' ? evt.toolName : 'tool';
+            const res = evt.result;
+            const text = toolResultText(res?.content);
+            opts.onToolResult({ name: tn, isError: evt.isError === true, text });
         }
     }
 }
+/** Flatten a tool result's `content` array (pi's `{type,text}[]`) into one string. */
+function toolResultText(content) {
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const c of content) {
+        if (c?.type === 'text' && typeof c.text === 'string')
+            parts.push(c.text);
+    }
+    return parts.join('');
+}
 // ─── Unified runChild ────────────────────────────────────────────────────────
 export function runChild(spawn, invocation, cwd, signal, opts) {
     return new Promise(resolve => {

package/dist/task/accept-debt.d.ts

@@ -1,26 +1,43 @@
-/** One accepted-despite-FAIL record: the task and why its VERIFY failed. */
+/**
+ * Provenance of a recorded defect:
+ *   - 'accepted'       — the user chose ACCEPT despite a verify-FAIL (the original class).
+ *   - 'enforce-revert' — an enforce-pass re-verify FAILED and the enforce edits were
+ *     reverted; the FAIL indicted the ORIGINAL work (mx5 run 10 TASK_0004: "Missing
+ *     server entry point … the Hono server cannot be started"), so the terminal defect
+ *     was FOUND and then erased by the very mechanism that found it. Persisted here so
+ *     the final gate re-checks and surfaces it instead of letting it die with the revert.
+ */
+export type DebtOrigin = 'accepted' | 'enforce-revert';
+/** One recorded defect: the task, why its VERIFY failed, and how it was recorded. */
 export interface AcceptDebt {
     taskId: string;
     reason: string;
+    /** Absent in legacy 2-field records → treated as 'accepted'. */
+    origin?: DebtOrigin;
 }
 export declare function acceptDebtFile(cwd: string): string;
 /** The raw stored ledger ('' when none recorded yet). Parse with parseAcceptDebts. */
 export declare function readAcceptDebtsRaw(cwd: string): Promise<string>;
 /**
- * Parse the stored ledger into records. A line without the separator (a reason but
- * no id, e.g. hand-edited) parses with an empty taskId rather than being dropped —
- * a recorded debt is never silently lost.
+ * Parse the stored ledger into records. Fields are tab-separated: `id`, `reason`, and
+ * an optional `origin` (legacy 2-field records have no origin → 'accepted'). Because a
+ * stored reason is tab-normalised (see normaliseReason), splitting on the separator is
+ * unambiguous. A line without any separator (a reason but no id, e.g. hand-edited)
+ * parses with an empty taskId rather than being dropped — a recorded debt is never
+ * silently lost.
  */
 export declare function parseAcceptDebts(raw: string): AcceptDebt[];
 /** Read + parse in one step. */
 export declare function readAcceptDebts(cwd: string): Promise<AcceptDebt[]>;
+/** Record a user-ACCEPTED-despite-verify-FAIL debt. */
+export declare function recordAcceptDebt(cwd: string, taskId: string, reason: string): Promise<void>;
 /**
- * Append one accepted-despite-FAIL record, deduplicated against what is already
- * stored (case-insensitive on task id + reason), keeping the newest MAX_DEBTS.
- * Failures are swallowed — the ledger is an auditing aid, never a blocker of the
- * gate sequence that calls it.
+ * Record an ENFORCE-REVERT debt (mx5 run 10 item 3): an enforce re-verify FAILED and
+ * the enforce edits were reverted, but the FAIL indicted the ORIGINAL work — so the
+ * defect is still in the shipped tree. Durable so the final gate re-checks/surfaces it
+ * rather than letting it die with the revert.
  */
-export declare function recordAcceptDebt(cwd: string, taskId: string, reason: string): Promise<void>;
+export declare function recordEnforceRevertDebt(cwd: string, taskId: string, reason: string): Promise<void>;
 /** Overwrite the ledger with exactly these records (used to prune resolved debts). */
 export declare function writeAcceptDebts(cwd: string, debts: AcceptDebt[]): Promise<void>;
 /**
@@ -50,3 +67,5 @@ export declare function recheckAcceptDebts(debts: AcceptDebt[], opts: {
  * picker). Empty when nothing is open.
  */
 export declare function buildAcceptDebtNote(open: AcceptDebt[]): string;
+/** One-line provenance label for a debt, for the surfaced report. */
+export declare function describeDebt(d: AcceptDebt): string;

package/dist/task/auto-orchestrator.d.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI, ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
 import { type FinalGateFixFn } from './gate-deps.js';
 import { type GateDeps } from './task-gates.js';
-import type { AcceptDebt } from './accept-debt.js';
+import { type AcceptDebt } from './accept-debt.js';
 /**
  * Injectable seams so the planner and loop are testable without spawning pi.
  * `runChild` is the planning-only seam used by planAuto; everything else (runTask,
@@ -30,7 +30,7 @@ export interface AutoDeps extends GateDeps {
      * own static checks plus its own test/build commands, unaided. Absent (tests /
      * gate off) → the run completes as before.
      */
-    finalGate?: (cwd: string) => Promise<{
+    finalGate?: (cwd: string, planText?: string) => Promise<{
         ok: boolean;
         reason: string;
         openDebts?: AcceptDebt[];

package/dist/task/auto-orchestrator.js

@@ -27,10 +27,12 @@ import { buildGateDeps } from './gate-deps.js';
 import { runGatesForTask } from './task-gates.js';
 import { gitUnmergedPaths, gitStashRef } from './auto-commit.js';
 import { runFinalIntegrationGate } from './final-gate.js';
+import { describeDebt } from './accept-debt.js';
 import { classifyFinalGateAnswer, MAX_FINAL_GATE_AUTOFIX, FINAL_LEAVE_LABEL, FINAL_LEAVE_VALUE, FINAL_ACCEPT_LABEL, FINAL_ACCEPT_VALUE, FINAL_AUTOFIX_LABEL, FINAL_AUTOFIX_VALUE } from './final-gate-fix.js';
 import { getConfig } from '../config/config.js';
 import { configureResearchRun } from '../workers/research-cache.js';
 import { CONTRACT_EXTRACT_PROMPT, parseContractLines, keepGroundedContracts, appendContracts } from './contracts.js';
+import { LAUNCH_EXTRACT_PROMPT, parseScriptLines, keepGroundedScripts, appendDeclaredScripts } from './launch-contract.js';
 // Hard ceiling on clarify questions per feature. The loop is open-ended (it stops
 // when the model emits NONE), but a model that never says NONE would otherwise
 // barrage the user — the real mx5 run asked 10, several of them redundant.
@@ -534,6 +536,21 @@ export async function planAuto(ctx, cwd, feature, deps) {
     catch {
         // best-effort registry
     }
+    // Launch contract (mx5 run 10 item 4): extract the package/build SCRIPTS the design
+    // declares the project must expose (`migrate`/`seed` fell through decompose and
+    // shipped missing, unchecked). Each emitted name is re-grounded against the design
+    // (keepGroundedScripts — kept only if the design backticks it), so the final gate's
+    // manifest diff can never false-flag a hallucinated script. Best-effort.
+    try {
+        const scriptRaw = await deps.runChild('launch-extract', '', LAUNCH_EXTRACT_PROMPT(featureForModel));
+        const grounded = keepGroundedScripts(parseScriptLines(scriptRaw), featureForModel);
+        logPlanDebug(cwd, `launch-contract extraction: ${grounded.length} grounded script(s) kept`
+            + ` from ${parseScriptLines(scriptRaw).length} emitted`);
+        await appendDeclaredScripts(cwd, grounded);
+    }
+    catch {
+        // best-effort artifact
+    }
     // Thread the feature's spec doc(s) into every title so each per-task
     // pipeline — which only ever sees its title — reads the real spec instead of
     // a lossy one-line paraphrase of it.
@@ -617,8 +634,8 @@ function defaultDeps(ctx, cwd, signal, title) {
         stashRef: cwd2 => gitStashRef(cwd2, signal),
         // The final integration gate follows the `verify work` switch: it is the
         // run-level half of the same verification story.
-        finalGate: cwd2 => getConfig().verifyWork ?
-            runFinalIntegrationGate(cwd2)
+        finalGate: (cwd2, planText) => getConfig().verifyWork ?
+            runFinalIntegrationGate(cwd2, undefined, undefined, undefined, planText)
             : Promise.resolve({ ok: true, reason: 'disabled' })
     };
 }
@@ -679,9 +696,16 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                             // recording must never break the gate
                         }
                     };
-                    let fin = await deps.finalGate(cwd);
-                    if (!fin.ok)
-                        await recGate(`final-gate: FAIL — ${fin.reason.slice(0, 300)}`);
+                    // Hand the parent plan (the task list) to the gate so it can tell a
+                    // served app from a CLI: the boot check requires a listener only for
+                    // the former (mx5 run 10 — a CSS watcher satisfied "still alive").
+                    let fin = await deps.finalGate(cwd, body);
+                    // Record the outcome symmetrically (mx5 run 10 item 7): only FAIL was
+                    // ever trailed, so a PASSing gate was indistinguishable from a gate
+                    // that never ran. The PASS reason names the commands that were run.
+                    await recGate(fin.ok ?
+                        `final-gate: PASS — ${fin.reason.slice(0, 300)}`
+                        : `final-gate: FAIL — ${fin.reason.slice(0, 300)}`);
                     // ACCEPT-debt re-check surfacing (mx5 run 4 B3 / run 8 TASK_0012):
                     // tasks the user accepted despite a verify-FAIL that the gate could
                     // not prove resolved against the current tree. Surface them at the
@@ -690,9 +714,9 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                     // already a human decision, so this reports, it does not re-fail.
                     if (fin.openDebts && fin.openDebts.length > 0) {
                         for (const d of fin.openDebts) {
-                            await recGate(`accept-debt STILL OPEN — ${d.taskId || '(unknown task)'} was ACCEPTED despite verify-FAIL: ${d.reason.slice(0, 240)}`);
+                            await recGate(`defect STILL OPEN — ${d.taskId || '(unknown task)'}: ${describeDebt(d)}: ${d.reason.slice(0, 240)}`);
                         }
-                        active.ui.notify(`${id}: ${fin.openDebts.length} task(s) accepted despite verify-FAIL are STILL unresolved at run end — see the gate trail.`, 'warning');
+                        active.ui.notify(`${id}: ${fin.openDebts.length} recorded verify-FAIL defect(s) are STILL unresolved at run end — see the gate trail.`, 'warning');
                     }
                     // Resolution loop: Leave-failed (recommended) / Autofix (bounded,
                     // model-driven fix pass + gate re-run — run 7's gap: the picker

package/dist/task/child-runner.js

@@ -7,7 +7,8 @@
  */
 import { spawn } from 'node:child_process';
 import { getPiInvocation } from '../shared/pi-invocation.js';
-import { runChild as runChildUnified, CHILD_BASE_ARGS } from '../shared/child-process.js';
+import { runChild as runChildUnified } from '../shared/child-process.js';
+import { childBaseArgs } from '../shared/child-extensions.js';
 import { LoopDetector } from './loop-detector.js';
 import { detectLeakedToolCall, leakedToolCallHint, MAX_LEAK_RETRIES } from '../shared/leaked-tool-call.js';
 import { readSection, setTaskSection } from './task-io.js';
@@ -60,7 +61,7 @@ export function childArgs(tools) {
     // runChild below / getPiInvocation), so a large inlined-design prompt can't
     // overflow the OS command-line limit (Windows `spawn ENAMETOOLONG`).
     const toolFlags = tools === '' ? ['--no-tools'] : ['--tools', tools];
-    return [...CHILD_BASE_ARGS, '--mode', 'json', ...toolFlags];
+    return [...childBaseArgs(), '--mode', 'json', ...toolFlags];
 }
 // Sentinel error thrown when the user dismisses a grill-me dialog.
 // Defined here (not in failure-classifier.ts) to avoid circular dependency.

package/dist/task/final-gate.d.ts

@@ -51,9 +51,25 @@ export interface BootDeps {
     } | null;
     /** Terminate a pid we attribute to ourselves; returns whether it was signalled. */
     reap?: (pid: number) => boolean;
+    /**
+     * Does process group `pgid` currently own a LISTENing TCP socket? Drives the
+     * served-app boot check (mx5 run 10): a watcher (`dev` = tailwind/bundler
+     * --watch) stays alive forever without ever listening, so "still alive after the
+     * grace window = PASS" blessed a project that cannot serve a single request.
+     * Injected so the listener requirement is deterministically testable without a
+     * real socket; the default probes ss/lsof + pgid.
+     */
+    groupHasListener?: (pgid: number) => boolean;
 }
 /**
- * Exercise the start command ONCE, with no port/URL/framework knowledge — the
+ * Does the finished run stand up a listening HTTP server? Deterministic, from the
+ * built manifest (a server-framework dependency is the plan's own artifact) OR, when
+ * available, the plan/spec text. Used to decide whether the boot check must observe a
+ * LISTENER (served app) or may pass on mere survival / quick exit (CLI project).
+ */
+export declare function detectsServedApp(cwd: string, planText?: string): boolean;
+/**
+ * Exercise the start command ONCE. For a CLI project (`expectServer` false) the
  * command's own fate within the grace window decides:
  *
  *   - non-zero exit (or signal death) before the window closes → FAIL, output tail;
@@ -61,9 +77,22 @@ export interface BootDeps {
  *   - still alive when the window closes → PASS, then the whole process group is
  *     killed (detached spawn = own group; SIGTERM, escalating to SIGKILL).
  *
+ * For a SERVED app (`expectServer` true — the spec/plan promised an HTTP server) mere
+ * survival is not enough: a watcher (`dev` = tailwind/bundler --watch) stays alive
+ * forever without ever listening, and a type-only entrypoint exits 0 in <1s having
+ * served nothing (mx5 run 10 — both were blessed by the survival rule). The boot then
+ * PASSes only once a LISTENing socket owned by our process group is observed; if the
+ * command exits, or the grace window closes, with no listener ever seen → FAIL naming
+ * that a listening server was expected. (The listener requirement needs pgid probing,
+ * absent on win32, where `expectServer` collapses to the survival rule — best-effort,
+ * never a false FAIL on a platform we cannot probe.)
+ *
  * Env-gap contract as everywhere: spawn error (ENOENT) or exit 127 → skip.
  */
-export declare function runBootCheck(cwd: string, [bin, args]: HealthCommand, graceMs?: number): Promise<BootOutcome>;
+export declare function runBootCheck(cwd: string, [bin, args]: HealthCommand, graceMs?: number, opts?: {
+    expectServer?: boolean;
+    deps?: BootDeps;
+}): Promise<BootOutcome>;
 /**
  * Labels (`bin args…`) of every command the gate CAN currently discover — the
  * static half (repo-health) plus the integration half. Pure discovery, nothing
@@ -78,5 +107,5 @@ export declare function discoverGateCommandLabels(cwd: string): string[];
  * the start command — whole-repo, verbatim, unaided. Deterministic (no model).
  * First real failure wins.
  */
-export declare function runFinalIntegrationGate(cwd: string, timeoutMs?: number, bootGraceMs?: number, bootDeps?: BootDeps): Promise<FinalGateOutcome>;
+export declare function runFinalIntegrationGate(cwd: string, timeoutMs?: number, bootGraceMs?: number, bootDeps?: BootDeps, planText?: string): Promise<FinalGateOutcome>;
 export {};