mustflow 2.103.21 → 2.103.22

package/README.md

@@ -142,7 +142,7 @@ mustflow installs and validates an agent workflow for user projects.
 - Runs only allowed one-shot commands within a timeout via `mf run <intent>` or `mf verify` when the selected intent is runnable.
 - Records blockers, contradictions, verification gaps, and remaining risks as a structured conflict ledger in verify, evidence, and dashboard reports.
 - Stores bounded failure replay capsules for failed `mf verify` runs so future agents can reproduce the intent, receipt, command fingerprint, and changed-file state without copying raw command output.
-- Writes command receipts under `.mustflow/state/runs/run-*` and atomically updates `.mustflow/state/runs/latest.json`.
+- Writes bounded command receipts under `.mustflow/state/runs/run-*`, atomically updates `.mustflow/state/runs/latest.json`, and rebuilds `.mustflow/state/runs/latest.index.json` for recent retained runs.
 - Generates a concise repository navigation map, `REPO_MAP.md`, with `mf map`.
 - Indexes and searches mustflow docs, skills, skill routes, command rules, command-effect locks, file fingerprints, and opt-in source anchor metadata with SQLite via `mf index` and `mf search`. The local SQLite file is a rebuildable lookup cache, not a memory store, audit log, command transcript store, command-authority source, or source-content database.
 - Tracks agent-created or agent-modified documentation needing prose review with `mf docs review`.
@@ -373,7 +373,7 @@ Command environments remove the project-local `node_modules/.bin` path from `PAT
 
 Use `mf verify --reason <event> --plan-only --json` to inspect matching verification intents, command eligibility, risk-priced evidence requirements, remaining gaps, and missing runnable coverage without executing commands. Use `mf run <intent> --dry-run --json` to inspect one resolved command intent without spawning a process or writing a run receipt. Plan-only verification includes a `decision_graph` that connects changed surfaces, classification reasons, command candidates, eligibility checks, effects, and gaps. When `.mustflow/cache/mustflow.sqlite` is fresh, scheduled entries also include read-only `effectGraph` metadata for write locks and lock conflicts. These graph rows are marked `explanation_only` and never grant command authority; `.mustflow/config/commands.toml` remains the only runnable command source.
 
-Each executed command run writes a run record under `.mustflow/state/runs/run-*` and atomically updates `.mustflow/state/runs/latest.json`. The record includes the intent name, working directory, timeout, exit code, timeout status, and the tail of stdout and stderr. `latest.json` is a root-scoped convenience pointer, not session-scoped proof; in multi-agent or multi-terminal workflows, use the per-run `receipt_path` or `mf run <intent> --json` output as the evidence for a specific run.
+Each executed command run writes a run record under `.mustflow/state/runs/run-*`, atomically updates `.mustflow/state/runs/latest.json`, and rebuilds `.mustflow/state/runs/latest.index.json` from retained `run-*` and `verify-*` directories. The record includes the intent name, working directory, timeout, exit code, timeout status, and the tail of stdout and stderr. `latest.json` is a root-scoped convenience pointer, not session-scoped proof; in multi-agent or multi-terminal workflows, use the per-run `receipt_path`, the retained index, or `mf run <intent> --json` output as the evidence for a specific run.
 
 ## Language and profiles
 

package/dist/cli/commands/run/execution.js

@@ -290,7 +290,7 @@ export async function executeRunCommand(request, reporter, lang = 'en', options
             stderrTailBytes: runReceiptPolicy.stderrTailBytes,
         }));
         if (options.writeLatestReceipt !== false) {
-            profiler.measure('receipt_write', () => writeRunReceipt(projectRoot, receipt));
+            profiler.measure('receipt_write', () => writeRunReceipt(projectRoot, receipt, runReceiptPolicy));
         }
         if (options.recordPerformanceHistory !== false) {
             profiler.measure('performance_history_write', () => recordRunPerformanceHistory(projectRoot, receipt));

package/dist/cli/commands/verify.js

@@ -15,7 +15,9 @@ import { riskPricedEvidenceRiskCount, } from '../../core/risk-priced-evidence.js
 import { countValidationRatchetVerdictEffects, createValidationRatchetRisks, } from '../../core/validation-ratchet.js';
 import { finishRunWriteBatchTracking, startRunWriteBatchTracking, } from '../../core/run-write-drift.js';
 import { createCommandEnv } from '../../core/command-env.js';
-import { readCommandContract } from '../../core/config-loading.js';
+import { readCommandContract, readMustflowConfigIfExists } from '../../core/config-loading.js';
+import { resolveRunReceiptRetentionPolicy } from '../../core/retention-policy.js';
+import { updateRunReceiptState } from '../../core/run-receipt-state.js';
 import { evaluateCommandPreconditions, } from '../../core/command-preconditions.js';
 import { DEFAULT_VERIFY_PARALLELISM, parseVerifyArgs, resolveVerifyParallelism, } from './verify/args.js';
 import { createInputFromChanged, createSyntheticClassificationReport, planErrorMessageKey, readInputFromClassificationReport, resolveVerifyInputPath, writeChangedPlan, } from './verify/input.js';
@@ -764,6 +766,7 @@ function writeVerifyRunReceipts(projectRoot, output, report, sourceAnchorRisks,
         manifest_path: statePaths.manifestPath,
     };
     writeJsonFileInsideWithoutSymlinks(projectRoot, resolveLatestVerifyRunReceiptPath(projectRoot), latest);
+    updateRunReceiptState(projectRoot, resolveRunReceiptRetentionPolicy(readMustflowConfigIfExists(projectRoot)));
     return outputWithReceiptPaths;
 }
 async function createVerifyOutput(input, planSource, projectRoot, lang, reproEvidence = null, externalChecks = [], parallelism = DEFAULT_VERIFY_PARALLELISM, parallelismReport = null) {

package/dist/core/retention-policy.js

@@ -5,6 +5,8 @@ export const DEFAULT_RETENTION_LIMITS = {
     repoMapMaxFileKb: 128,
     repoMapFailIfLarger: true,
     runReceiptMaxFileKb: 128,
+    runReceiptMaxItems: 50,
+    runReceiptMaxTotalMb: 10,
     contextMaxFileKb: 8,
     knowledgeMaxFileKb: 128,
 };
@@ -49,8 +51,8 @@ export function resolveRunReceiptRetentionPolicy(mustflowToml) {
     return {
         store: readString(runReceipts ?? {}, 'store') ?? 'repo_local_ignored',
         maxFileKb: readPositiveIntegerWithDefault(runReceipts, 'max_file_kb', DEFAULT_RETENTION_LIMITS.runReceiptMaxFileKb),
-        maxItems: readPositiveIntegerWithDefault(runReceipts, 'max_items', 1),
-        maxTotalMb: readPositiveIntegerWithDefault(runReceipts, 'max_total_mb', 1),
+        maxItems: readPositiveIntegerWithDefault(runReceipts, 'max_items', DEFAULT_RETENTION_LIMITS.runReceiptMaxItems),
+        maxTotalMb: readPositiveIntegerWithDefault(runReceipts, 'max_total_mb', DEFAULT_RETENTION_LIMITS.runReceiptMaxTotalMb),
         stdoutTailBytes: readPositiveIntegerWithDefault(runReceipts, 'keep_stdout_tail_bytes', DEFAULT_RUN_RECEIPT_TAIL_BYTES),
         stderrTailBytes: readPositiveIntegerWithDefault(runReceipts, 'keep_stderr_tail_bytes', DEFAULT_RUN_RECEIPT_TAIL_BYTES),
     };

package/dist/core/run-receipt-state.js

@@ -0,0 +1,247 @@
+import { existsSync, lstatSync, readdirSync, readFileSync, rmSync } from 'node:fs';
+import path from 'node:path';
+import { ensureInside, writeJsonFileInsideWithoutSymlinks } from './safe-filesystem.js';
+const RUN_RECEIPT_SCHEMA_VERSION = '1';
+const RUN_RECEIPT_DIR = path.join('.mustflow', 'state', 'runs');
+const LATEST_RUN_RECEIPT_INDEX = 'latest.index.json';
+const STATE_DIR_PREFIXES = ['run-', 'verify-'];
+const MIN_RETAINED_RUN_DIRS = 1;
+function toPosixPath(value) {
+    return value.split(path.sep).join('/');
+}
+function stateRunsDir(projectRoot) {
+    return path.join(projectRoot, RUN_RECEIPT_DIR);
+}
+function latestIndexPath(projectRoot) {
+    return path.join(stateRunsDir(projectRoot), LATEST_RUN_RECEIPT_INDEX);
+}
+function runStateKind(name) {
+    return STATE_DIR_PREFIXES.find((prefix) => name.startsWith(prefix)) ?? null;
+}
+function isMissingPathError(error) {
+    return error instanceof Error && 'code' in error && error.code === 'ENOENT';
+}
+function getStateRunSortKey(name) {
+    const match = /^(?:run|verify)-(.+)$/u.exec(name);
+    return match?.[1] ?? name;
+}
+function fileSizeBytes(filePath) {
+    try {
+        const stats = lstatSync(filePath);
+        if (stats.isSymbolicLink()) {
+            return 0;
+        }
+        if (stats.isFile()) {
+            return stats.size;
+        }
+        if (!stats.isDirectory()) {
+            return 0;
+        }
+        return readdirSync(filePath).reduce((total, entry) => total + fileSizeBytes(path.join(filePath, entry)), 0);
+    }
+    catch (error) {
+        if (isMissingPathError(error)) {
+            return 0;
+        }
+        throw error;
+    }
+}
+function readRunStateDirectories(projectRoot) {
+    const receiptDir = stateRunsDir(projectRoot);
+    if (!existsSync(receiptDir)) {
+        return [];
+    }
+    return readdirSync(receiptDir)
+        .map((name) => {
+        const kind = runStateKind(name);
+        if (!kind) {
+            return null;
+        }
+        const absolutePath = path.join(receiptDir, name);
+        const relativePath = toPosixPath(path.join(RUN_RECEIPT_DIR, name));
+        const stats = lstatSync(absolutePath);
+        if (!stats.isDirectory() || stats.isSymbolicLink()) {
+            return null;
+        }
+        return {
+            absolutePath,
+            relativePath,
+            name,
+            kind,
+            sortKey: getStateRunSortKey(name),
+            sizeBytes: fileSizeBytes(absolutePath),
+        };
+    })
+        .filter((entry) => Boolean(entry))
+        .sort(compareRunStateDirectoriesDescending);
+}
+function compareRunStateDirectoriesDescending(left, right) {
+    const bySortKey = right.sortKey.localeCompare(left.sortKey);
+    if (bySortKey !== 0) {
+        return bySortKey;
+    }
+    return right.name.localeCompare(left.name);
+}
+function removeRunStateDirectory(projectRoot, directory) {
+    const runsDir = stateRunsDir(projectRoot);
+    ensureInside(runsDir, directory.absolutePath);
+    const relativeToRunsDir = path.relative(runsDir, directory.absolutePath);
+    if (relativeToRunsDir.startsWith('..') || path.isAbsolute(relativeToRunsDir) || runStateKind(path.basename(directory.absolutePath)) === null) {
+        throw new Error(`Refusing to remove unexpected run receipt path: ${directory.relativePath}`);
+    }
+    const stats = lstatSync(directory.absolutePath);
+    if (!stats.isDirectory() || stats.isSymbolicLink()) {
+        throw new Error(`Refusing to remove non-directory run receipt path: ${directory.relativePath}`);
+    }
+    rmSync(directory.absolutePath, { recursive: true, force: true });
+}
+function applyRunReceiptRetention(projectRoot, policy) {
+    const directories = readRunStateDirectories(projectRoot);
+    const maxItems = Math.max(MIN_RETAINED_RUN_DIRS, policy.maxItems);
+    const maxTotalBytes = Math.max(1, policy.maxTotalMb) * 1024 * 1024;
+    const kept = new Set(directories.slice(0, maxItems).map((directory) => directory.name));
+    let totalBytes = directories
+        .filter((directory) => kept.has(directory.name))
+        .reduce((total, directory) => total + directory.sizeBytes, 0);
+    for (const directory of directories.slice(maxItems)) {
+        removeRunStateDirectory(projectRoot, directory);
+    }
+    for (const directory of [...directories].reverse()) {
+        if (kept.size <= MIN_RETAINED_RUN_DIRS || !kept.has(directory.name) || totalBytes <= maxTotalBytes) {
+            continue;
+        }
+        removeRunStateDirectory(projectRoot, directory);
+        kept.delete(directory.name);
+        totalBytes -= directory.sizeBytes;
+    }
+    return readRunStateDirectories(projectRoot);
+}
+function readJsonObject(filePath) {
+    try {
+        const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function stringField(value) {
+    return typeof value === 'string' ? value : null;
+}
+function stringArrayField(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === 'string') ? value : undefined;
+}
+function createRunEntry(directory) {
+    const receipt = readJsonObject(path.join(directory.absolutePath, 'receipt.json'));
+    if (!receipt || receipt.command !== 'run' || typeof receipt.receipt_path !== 'string') {
+        return null;
+    }
+    return {
+        command: 'run',
+        intent: stringField(receipt.intent),
+        status: stringField(receipt.status),
+        cwd: stringField(receipt.cwd),
+        started_at: stringField(receipt.started_at),
+        finished_at: stringField(receipt.finished_at),
+        correlation_id: stringField(receipt.correlation_id),
+        receipt_path: receipt.receipt_path,
+        run_dir: directory.relativePath,
+    };
+}
+function readVerifyIntentEntry(directory, manifest, manifestPath, manifestReceipt) {
+    const receiptPath = stringField(manifestReceipt.receipt_path);
+    if (!receiptPath) {
+        return null;
+    }
+    const runsDir = path.dirname(directory.absolutePath);
+    const receiptAbsolutePath = path.resolve(runsDir, ...receiptPath.split('/').slice(3));
+    ensureInside(runsDir, receiptAbsolutePath);
+    const receipt = readJsonObject(receiptAbsolutePath);
+    return {
+        command: 'verify',
+        intent: stringField(manifestReceipt.intent),
+        status: stringField(manifestReceipt.status),
+        cwd: stringField(receipt?.cwd),
+        started_at: stringField(receipt?.started_at),
+        finished_at: stringField(receipt?.finished_at),
+        correlation_id: stringField(manifest.correlation_id),
+        verification_plan_id: stringField(manifest.verification_plan_id),
+        reason: stringField(manifest.reason),
+        reasons: stringArrayField(manifest.reasons),
+        receipt_path: receiptPath,
+        manifest_path: manifestPath,
+        run_dir: directory.relativePath,
+    };
+}
+function createVerifyEntries(directory) {
+    const manifestPath = toPosixPath(path.join(directory.relativePath, 'manifest.json'));
+    const manifest = readJsonObject(path.join(directory.absolutePath, 'manifest.json'));
+    if (!manifest || manifest.command !== 'verify') {
+        return [];
+    }
+    const summaryEntry = {
+        command: 'verify',
+        intent: null,
+        status: stringField(manifest.status ?? manifest.execution_status),
+        correlation_id: stringField(manifest.correlation_id),
+        verification_plan_id: stringField(manifest.verification_plan_id),
+        reason: stringField(manifest.reason),
+        reasons: stringArrayField(manifest.reasons),
+        manifest_path: manifestPath,
+        run_dir: directory.relativePath,
+    };
+    const receiptEntries = Array.isArray(manifest.receipts)
+        ? manifest.receipts
+            .map((receipt) => receipt && typeof receipt === 'object'
+            ? readVerifyIntentEntry(directory, manifest, manifestPath, receipt)
+            : null)
+            .filter((entry) => Boolean(entry))
+        : [];
+    return [summaryEntry, ...receiptEntries];
+}
+function createIndexEntries(directories) {
+    return directories.flatMap((directory) => {
+        if (directory.kind === 'run-') {
+            const entry = createRunEntry(directory);
+            return entry ? [entry] : [];
+        }
+        return createVerifyEntries(directory);
+    });
+}
+function entryTargetPath(entry) {
+    return entry.receipt_path ?? entry.manifest_path ?? null;
+}
+function latestLookupEntries(entries) {
+    const latestByIntent = {};
+    const latestByCwdIntent = {};
+    for (const entry of entries) {
+        const targetPath = entryTargetPath(entry);
+        if (!entry.intent || !targetPath) {
+            continue;
+        }
+        latestByIntent[entry.intent] ??= targetPath;
+        if (entry.cwd) {
+            latestByCwdIntent[`${entry.cwd}::${entry.intent}`] ??= targetPath;
+        }
+    }
+    return { latestByIntent, latestByCwdIntent };
+}
+export function updateRunReceiptState(projectRoot, policy) {
+    const retainedDirectories = applyRunReceiptRetention(projectRoot, policy);
+    const entries = createIndexEntries(retainedDirectories);
+    const lookups = latestLookupEntries(entries);
+    const index = {
+        schema_version: RUN_RECEIPT_SCHEMA_VERSION,
+        kind: 'run_receipt_index',
+        generated_at: new Date().toISOString(),
+        retention: {
+            max_items: policy.maxItems,
+            max_total_mb: policy.maxTotalMb,
+            retained_run_dirs: retainedDirectories.length,
+        },
+        entries,
+        latest_by_intent: lookups.latestByIntent,
+        latest_by_cwd_intent: lookups.latestByCwdIntent,
+    };
+    writeJsonFileInsideWithoutSymlinks(projectRoot, latestIndexPath(projectRoot), index);
+}

package/dist/core/run-receipt.js

@@ -4,6 +4,7 @@ import { createStateRunId } from './atomic-state-write.js';
 import { COMMAND_OUTPUT_LIMIT_SCOPE } from './command-output-limits.js';
 import { decodeUtf8Tail } from './bounded-output.js';
 import { DEFAULT_RUN_RECEIPT_TAIL_BYTES } from './retention-policy.js';
+import { updateRunReceiptState } from './run-receipt-state.js';
 import { writeJsonFileInsideWithoutSymlinks } from './safe-filesystem.js';
 import { redactSecretLikeText } from './secret-redaction.js';
 const RUN_RECEIPT_SCHEMA_VERSION = '1';
@@ -286,7 +287,7 @@ export function createRunReceipt(input) {
         receipt_path: getReceiptRelativePath(input.receiptPath),
     };
 }
-export function writeRunReceipt(projectRoot, receipt) {
+export function writeRunReceipt(projectRoot, receipt, policy) {
     const receiptDir = path.join(projectRoot, RUN_RECEIPT_DIR);
     const latestPath = path.join(receiptDir, LATEST_RUN_RECEIPT);
     const receiptPath = path.resolve(projectRoot, receipt.receipt_path);
@@ -296,4 +297,7 @@ export function writeRunReceipt(projectRoot, receipt) {
     }
     writeJsonFileInsideWithoutSymlinks(projectRoot, receiptPath, receipt);
     writeJsonFileInsideWithoutSymlinks(projectRoot, latestPath, receipt);
+    if (policy) {
+        updateRunReceiptState(projectRoot, policy);
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mustflow",
-  "version": "2.103.21",
+  "version": "2.103.22",
   "description": "Agent workflow documents and CLI for mustflow repository roots.",
   "type": "module",
   "license": "MIT-0",

package/templates/default/common/.mustflow/config/mustflow.toml

@@ -350,8 +350,8 @@ on_limit = "report"
 [retention.run_receipts]
 store = "repo_local_ignored"
 max_file_kb = 128
-max_items = 1
-max_total_mb = 1
+max_items = 50
+max_total_mb = 10
 keep_stdout_tail_bytes = 65536
 keep_stderr_tail_bytes = 65536
 

package/templates/default/i18n.toml

@@ -565,7 +565,7 @@ translations = {}
 [documents."skill.clarifying-question-gate"]
 source = "locales/en/.mustflow/skills/clarifying-question-gate/SKILL.md"
 source_locale = "en"
-revision = 3
+revision = 4
 translations = {}
 
 [documents."skill.heuristic-candidate-selection"]

package/templates/default/locales/en/.mustflow/skills/clarifying-question-gate/SKILL.md

@@ -2,7 +2,7 @@
 mustflow_doc: skill.clarifying-question-gate
 locale: en
 canonical: true
-revision: 3
+revision: 4
 lifecycle: mustflow-owned
 authority: procedure
 name: clarifying-question-gate
@@ -96,6 +96,8 @@ verification, and stop-or-ask boundary.
 - Reversibility classification for each decision: cheap/reversible, moderate, or expensive/hard to
   roll back.
 - A recommended option for each blocking question, with the tradeoff of at least one alternative.
+- Host input capability when known: whether a structured user-input mechanism such as Codex
+  `request_user_input` or MCP elicitation is explicitly available in the current runtime.
 - A request-state decision: `ready`, `ready_with_assumptions`, `needs_confirmation`,
   `blocked_by_conflict`, or `insufficient_evidence`.
 - A normalized task contract when the original request is vague enough to risk drift: goal, current
@@ -123,6 +125,8 @@ verification, and stop-or-ask boundary.
   collection, or broad product discovery.
 - Product decisions are separated from engineering responsibilities. Do not ask whether to preserve
   existing style, avoid swallowed errors, add appropriate tests, or follow command contracts.
+- Structured input tools are optional host capabilities. Do not claim they exist, simulate their UI,
+  or depend on them unless the current host explicitly exposes them for this turn or tool call.
 
 <!-- mustflow-section: allowed-edits -->
 ## Allowed Edits
@@ -215,22 +219,40 @@ verification, and stop-or-ask boundary.
       and one meaningful alternative;
     - avoid open-ended prompts like "how should I implement this?" unless no responsible options can
       be framed from repository evidence.
-15. Do not ask bad engineering-delegation questions:
+15. Prefer structured user input for real blocking decisions when the host exposes it:
+    - use a structured input tool such as `request_user_input` or MCP elicitation only when it is
+      explicitly listed as available in the current runtime or tool call;
+    - use it for `needs_confirmation` or for a non-blocking `ready_with_assumptions` choice whose
+      answer would materially improve the result without stopping all progress;
+    - ask at most three short questions, and prefer one question when the answer may change the next
+      question;
+    - provide two or three mutually exclusive choices, put the recommended choice first, and include
+      the concrete consequence or tradeoff for each choice;
+    - allow free-form input when the host mechanism supports it, because the listed options are a
+      steering aid rather than a closed product decision;
+    - use auto-resolution only for non-blocking choices with a narrow reversible default, and never
+      for destructive actions, publish or release decisions, credential or secret handling, data
+      deletion or migration, auth or billing policy, dependency adoption, or other explicit
+      confirmation gates;
+    - if no structured input mechanism is available, ask the same blocking decision as a concise
+      normal chat question when host policy allows it; do not invent a fake UI, long questionnaire,
+      or multiple-choice card in prose when the host explicitly forbids that fallback.
+16. Do not ask bad engineering-delegation questions:
     - "Should I add tests?"
     - "Should I handle errors?"
     - "Should I follow existing style?"
     - "Should I check current files?"
     - "Should I preserve existing behavior?"
-16. Use prompt rewriting only as an exception:
+17. Use prompt rewriting only as an exception:
     - the user explicitly asks for a prompt, issue, PR body, work order, or handoff for another
       agent;
     - the current request is too broken to execute and a normalized contract plus confirmation is the
       smallest safe next step.
     Otherwise, show the normalized contract only when it materially reduces drift, then proceed in
     the same conversation.
-17. If no blocking question remains, proceed without ceremony. State only the assumptions that matter
+18. If no blocking question remains, proceed without ceremony. State only the assumptions that matter
     to review or rollback.
-18. If a blocking question remains unanswered, do not implement around it. Offer the smallest safe
+19. If a blocking question remains unanswered, do not implement around it. Offer the smallest safe
     non-blocked action, such as read-only analysis, a plan, a reproduction, or a narrow preparatory
     refactor when another selected skill supports it.
 
@@ -241,6 +263,8 @@ verification, and stop-or-ask boundary.
 - The agent has not asked for facts it could read locally.
 - Expensive, user-owned, security-sensitive, data-affecting, dependency-affecting, and public-contract
   decisions are resolved before implementation.
+- Structured input tools are used only when available and only for bounded decisions that benefit
+  from user choice.
 - Safe assumptions are narrow, reversible, and reported.
 - Any normalized contract preserves the user's original request separately from repository-derived
   facts and safe assumptions.
@@ -288,6 +312,7 @@ run the specific configured verification intents required by the selected implem
 - Normalized task contract, only when needed, with `user_confirmed`, `repository_derived`,
   `safe_assumption`, and `unresolved` source tags
 - Blocking questions asked, with recommendation and tradeoff
+- Question delivery mode: structured host input, normal chat fallback, or not needed
 - Safe assumptions made
 - Decisions intentionally deferred
 - Implementation scope selected

package/templates/default/manifest.toml

@@ -1,6 +1,6 @@
 id = "default"
 name = "default"
-version = "2.103.21"
+version = "2.103.22"
 description = "Minimal workflow for LLM agents to read, edit, and verify their work in a repository."
 common_root = "common"
 locales_root = "locales"