substrate-ai 0.21.1 → 0.21.3

package/dist/{interactive-prompt-BBfPSxyJ.js → interactive-prompt-BM5RaXYG.js}

@@ -1,5 +1,5 @@
 import { createLogger } from "./logger-KeHncl-f.js";
-import { readCurrentRunId, resolveMainRepoRoot } from "./manifest-read-BhNRIiqm.js";
+import { readCurrentRunId, resolveMainRepoRoot } from "./manifest-read-B3gE46DX.js";
 import { join } from "node:path";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import * as readline from "node:readline";
@@ -180,4 +180,4 @@ async function runInteractivePrompt(decisionContext) {
 
 //#endregion
 export { runInteractivePrompt };
-//# sourceMappingURL=interactive-prompt-BBfPSxyJ.js.map
+//# sourceMappingURL=interactive-prompt-BM5RaXYG.js.map

package/dist/{manifest-read-BhNRIiqm.js → manifest-read-B3gE46DX.js}

@@ -1,5 +1,5 @@
 import { createLogger } from "./logger-KeHncl-f.js";
-import { LEARNING_FINDING, createDecision, getDecisionsByCategory } from "./dist-BkhYgJWo.js";
+import { LEARNING_FINDING, createDecision, getDecisionsByCategory } from "./dist-CpnLJuVw.js";
 import * as path$1 from "path";
 import { join } from "path";
 import { readFile } from "fs/promises";
@@ -3087,7 +3087,21 @@ function executeProbeOnHost(probe, options = {}) {
 * registry, os. Open string so novel names don't cause silent skips.
 */
 const ExternalStateDependencySchema = z.string();
-const StoryFrontmatterSchema = z.object({ external_state_dependencies: z.array(ExternalStateDependencySchema).optional().default([]) });
+/**
+* Journey tags (acceptance-gate story A0.2): `journeys: [UJ-x]` declares which
+* registry journeys this story claims to deliver. Tolerant by design — a bare
+* string coerces to a one-element list, and any non-coercible shape falls back
+* to `[]` via `.catch` WITHOUT failing the whole frontmatter block (a malformed
+* journey tag must never silently drop `external_state_dependencies`).
+* Untagged is legal: the epic-close coverage invariant (A0.3) is the backstop;
+* tags only buy earlier detection. Unknown-id validation happens against the
+* trusted-tree registry in the create-story workflow, not here.
+*/
+const JourneyTagsSchema = z.union([z.string().transform((s) => [s]), z.array(z.string())]).catch([]);
+const StoryFrontmatterSchema = z.object({
+	external_state_dependencies: z.array(ExternalStateDependencySchema).optional().default([]),
+	journeys: JourneyTagsSchema.optional().default([])
+});
 /**
 * Parse the optional YAML frontmatter block from a story artifact.
 *
@@ -4963,6 +4977,342 @@ async function runAcTraceabilityCheck(input) {
 	};
 }
 
+//#endregion
+//#region packages/sdlc/dist/acceptance/registry.js
+/** Repo-relative path of the registry — the single canonical location. */
+const JOURNEY_REGISTRY_PATH = ".substrate/acceptance/journeys.yaml";
+const JourneySurfaceSchema = z.enum([
+	"email",
+	"cli",
+	"file",
+	"web"
+]);
+const JourneyEndStateSchema = z.object({
+	id: z.string().min(1, "end-state id must be a non-empty string"),
+	given: z.string().min(1, "given must be a non-empty string"),
+	walk: z.string().min(1, "walk must be a non-empty string"),
+	then: z.string().min(1, "then must be a non-empty string")
+});
+const JourneySchema = z.object({
+	id: z.string().min(1, "journey id must be a non-empty string"),
+	title: z.string().min(1, "title must be a non-empty string"),
+	criticality: z.enum(["critical", "standard"]),
+	surfaces: z.array(JourneySurfaceSchema).min(1, "a journey must declare at least one surface"),
+	epic: z.number().int().positive().optional(),
+	end_states: z.array(JourneyEndStateSchema).min(1, "a journey must declare at least one end_state — a journey with none is unjudgeable")
+});
+const JourneyRegistrySchema = z.object({
+	version: z.number().int().positive("version must be a positive integer"),
+	journeys: z.array(JourneySchema)
+}).superRefine((registry, ctx) => {
+	const seenJourneyIds = new Map();
+	registry.journeys.forEach((journey, i) => {
+		const firstIndex = seenJourneyIds.get(journey.id);
+		if (firstIndex !== void 0) ctx.addIssue({
+			code: "custom",
+			path: [
+				"journeys",
+				i,
+				"id"
+			],
+			message: `duplicate journey id "${journey.id}" (first declared at journeys[${firstIndex}])`
+		});
+		else seenJourneyIds.set(journey.id, i);
+		const seenEndStateIds = new Map();
+		journey.end_states.forEach((endState, j) => {
+			const firstEs = seenEndStateIds.get(endState.id);
+			if (firstEs !== void 0) ctx.addIssue({
+				code: "custom",
+				path: [
+					"journeys",
+					i,
+					"end_states",
+					j,
+					"id"
+				],
+				message: `duplicate end-state id "${endState.id}" in journey "${journey.id}" (first declared at end_states[${firstEs}])`
+			});
+			else seenEndStateIds.set(endState.id, j);
+		});
+	});
+});
+function zodErrorToValidationIssues(error) {
+	return error.issues.map((issue) => ({
+		path: issue.path.length > 0 ? issue.path.map(String).join(".") : "(root)",
+		message: issue.message
+	}));
+}
+/**
+* Parse and validate registry YAML content.
+*
+* Never throws: malformed YAML, non-object documents, and schema violations
+* all come back as named, pathed issues.
+*/
+function parseJourneyRegistry(yamlContent) {
+	let doc;
+	try {
+		doc = load(yamlContent);
+	} catch (err) {
+		const message = err instanceof YAMLException ? err.message : String(err);
+		return {
+			ok: false,
+			issues: [{
+				path: "(root)",
+				message: `malformed YAML: ${message}`
+			}]
+		};
+	}
+	if (doc === null || doc === void 0) return {
+		ok: false,
+		issues: [{
+			path: "(root)",
+			message: "registry file is empty"
+		}]
+	};
+	const result = JourneyRegistrySchema.safeParse(doc);
+	if (!result.success) return {
+		ok: false,
+		issues: zodErrorToValidationIssues(result.error)
+	};
+	return {
+		ok: true,
+		registry: result.data
+	};
+}
+
+//#endregion
+//#region packages/sdlc/dist/acceptance/coverage.js
+/**
+* Compute the coverage state of every journey audited at this scope.
+*
+* - `{epic: n}` audits journeys declaring `epic: n`.
+* - `{final: true}` audits the FULL registry (epicless journeys have no
+*   earlier audit point; epic-scoped ones are re-audited — idempotent).
+*
+* State precedence: deferred > walked-fail > walked-pass > unwalked/unclaimed.
+* An operator deferral wins over everything (explicit scope decision); a fail
+* verdict wins over a pass (any failing end-state fails the journey).
+*/
+function computeJourneyCoverage(input) {
+	const { registry, claims, verdicts, deferredJourneyIds, scope } = input;
+	const audited = registry.journeys.filter((j) => "final" in scope ? true : j.epic === scope.epic);
+	const claimsByJourney = new Map();
+	for (const claim of claims) {
+		const owners = claimsByJourney.get(claim.journeyId) ?? [];
+		if (!owners.includes(claim.storyKey)) owners.push(claim.storyKey);
+		claimsByJourney.set(claim.journeyId, owners);
+	}
+	const deferred = new Set(deferredJourneyIds);
+	const verdictByJourney = new Map();
+	for (const v of verdicts) {
+		const existing = verdictByJourney.get(v.journeyId);
+		verdictByJourney.set(v.journeyId, existing === "fail" ? "fail" : v.verdict);
+	}
+	return audited.map((journey) => {
+		const ownerStories = claimsByJourney.get(journey.id) ?? [];
+		let state;
+		if (deferred.has(journey.id)) state = "deferred";
+		else {
+			const verdict = verdictByJourney.get(journey.id);
+			if (verdict === "fail") state = "walked-fail";
+			else if (verdict === "pass") state = "walked-pass";
+			else state = ownerStories.length > 0 ? "unwalked" : "unclaimed";
+		}
+		return {
+			journeyId: journey.id,
+			title: journey.title,
+			criticality: journey.criticality,
+			...journey.epic !== void 0 ? { epic: journey.epic } : {},
+			state,
+			ownerStories
+		};
+	});
+}
+/** Aggregate counts for the `acceptance:coverage` event payload. */
+function summarizeCoverage(entries) {
+	const summary = {
+		"walked-pass": 0,
+		"walked-fail": 0,
+		deferred: 0,
+		unclaimed: 0,
+		unwalked: 0
+	};
+	for (const entry of entries) summary[entry.state] += 1;
+	return summary;
+}
+/** Repo-relative path of the operator deferral file. */
+const JOURNEY_DEFERRALS_PATH = ".substrate/acceptance/deferrals.yaml";
+const JourneyDeferralSchema = z.object({
+	journey: z.string().min(1),
+	reason: z.string().min(1, "a deferral must carry an operator reason"),
+	deferred_at: z.string().optional()
+});
+const JourneyDeferralsFileSchema = z.object({ deferrals: z.array(JourneyDeferralSchema) });
+/** Parse deferrals YAML. Never throws; malformed content comes back as issues. */
+function parseJourneyDeferrals(yamlContent) {
+	let doc;
+	try {
+		doc = load(yamlContent);
+	} catch (err) {
+		const message = err instanceof YAMLException ? err.message : String(err);
+		return {
+			ok: false,
+			issues: [{
+				path: "(root)",
+				message: `malformed YAML: ${message}`
+			}]
+		};
+	}
+	if (doc === null || doc === void 0) return {
+		ok: true,
+		deferrals: []
+	};
+	const result = JourneyDeferralsFileSchema.safeParse(doc);
+	if (!result.success) return {
+		ok: false,
+		issues: result.error.issues.map((issue) => ({
+			path: issue.path.length > 0 ? issue.path.map(String).join(".") : "(root)",
+			message: issue.message
+		}))
+	};
+	return {
+		ok: true,
+		deferrals: result.data.deferrals
+	};
+}
+
+//#endregion
+//#region packages/sdlc/dist/acceptance/loader.js
+/** stderr shapes that mean "the path is not in the tree at this ref" (absent, not an error). */
+const GIT_SHOW_ABSENT_PATTERNS = [
+	/does not exist in/i,
+	/exists on disk, but not in/i,
+	/path .* does not exist/i
+];
+/** Array-argv spawn — no shell, no interpolation, injection-safe by construction. */
+function runGitShow(repoRoot, ref, relPath) {
+	return new Promise((resolve$2) => {
+		let stdout = "";
+		let stderr = "";
+		const proc = spawn("git", ["show", `${ref}:${relPath}`], {
+			cwd: repoRoot,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		proc.stdout?.on("data", (chunk) => {
+			stdout += chunk.toString("utf-8");
+		});
+		proc.stderr?.on("data", (chunk) => {
+			stderr += chunk.toString("utf-8");
+		});
+		proc.on("error", (err) => {
+			resolve$2({
+				code: null,
+				stdout,
+				stderr,
+				spawnError: err.message
+			});
+		});
+		proc.on("close", (code) => {
+			resolve$2({
+				code,
+				stdout,
+				stderr
+			});
+		});
+	});
+}
+/**
+* Load the journey registry from the trusted main tree at `ref`.
+*
+* @param repoRoot absolute path of the TRUSTED repo root (the main tree, not a worktree)
+* @param ref git ref to read at — the dispatch snapshot ref (defaults to HEAD)
+*/
+async function loadJourneyRegistryFromTrustedTree(repoRoot, ref = "HEAD") {
+	const result = await runGitShow(repoRoot, ref, JOURNEY_REGISTRY_PATH);
+	if (result.spawnError !== void 0) return {
+		status: "error",
+		message: `git show could not be spawned: ${result.spawnError}`
+	};
+	if (result.code !== 0) {
+		if (GIT_SHOW_ABSENT_PATTERNS.some((p) => p.test(result.stderr))) return { status: "absent" };
+		return {
+			status: "error",
+			message: `git show ${ref}:${JOURNEY_REGISTRY_PATH} failed (exit ${String(result.code)}): ${result.stderr.trim()}`
+		};
+	}
+	const parsed = parseJourneyRegistry(result.stdout);
+	if (!parsed.ok) return {
+		status: "invalid",
+		issues: parsed.issues
+	};
+	return {
+		status: "ok",
+		registry: parsed.registry
+	};
+}
+/**
+* Load operator journey deferrals from the trusted tree at `ref`.
+* A0.3 note: `HEAD` at run end can include story-merged edits — full
+* tamper-hardening of this input is A1.3 scope (spec-tamper tripwire).
+*/
+async function loadJourneyDeferralsFromTrustedTree(repoRoot, ref = "HEAD") {
+	const result = await runGitShow(repoRoot, ref, JOURNEY_DEFERRALS_PATH);
+	if (result.spawnError !== void 0) return {
+		status: "error",
+		message: `git show could not be spawned: ${result.spawnError}`
+	};
+	if (result.code !== 0) {
+		if (GIT_SHOW_ABSENT_PATTERNS.some((p) => p.test(result.stderr))) return {
+			status: "ok",
+			deferrals: []
+		};
+		return {
+			status: "error",
+			message: `git show ${ref}:${JOURNEY_DEFERRALS_PATH} failed (exit ${String(result.code)}): ${result.stderr.trim()}`
+		};
+	}
+	const parsed = parseJourneyDeferrals(result.stdout);
+	if (!parsed.ok) return {
+		status: "invalid",
+		issues: parsed.issues
+	};
+	return {
+		status: "ok",
+		deferrals: parsed.deferrals
+	};
+}
+/**
+* Filesystem read for OPERATOR LINT ONLY (`substrate acceptance validate`).
+* Gate/judge code paths must use `loadJourneyRegistryFromTrustedTree`.
+*/
+async function loadJourneyRegistryFromFile(projectRoot) {
+	const filePath = join$1(projectRoot, JOURNEY_REGISTRY_PATH);
+	let content;
+	try {
+		content = await readFile$1(filePath, "utf-8");
+	} catch (err) {
+		const code = err.code;
+		if (code === "ENOENT" || code === "ENOTDIR") return { status: "absent" };
+		return {
+			status: "error",
+			message: `could not read ${filePath}: ${String(err)}`
+		};
+	}
+	const parsed = parseJourneyRegistry(content);
+	if (!parsed.ok) return {
+		status: "invalid",
+		issues: parsed.issues
+	};
+	return {
+		status: "ok",
+		registry: parsed.registry
+	};
+}
+
 //#endregion
 //#region packages/sdlc/dist/run-model/cli-flags.js
 /**
@@ -5167,6 +5517,7 @@ const PerStoryStateSchema = z.object({
 	escalation_detail: z.string().optional(),
 	commit_sha: z.string().optional(),
 	baseline_sha: z.string().optional(),
+	journeys: z.array(z.string()).optional(),
 	checkpoint_sha: z.string().optional(),
 	finalization: z.object({
 		mode: z.union([
@@ -5301,6 +5652,20 @@ const RunManifestSchema = z.object({
 	orchestrator_start_branch: z.string().optional(),
 	stopped_reason: z.string().optional(),
 	stopped_at: z.string().optional(),
+	journeys: z.array(z.object({
+		journeyId: z.string(),
+		title: z.string(),
+		criticality: z.enum(["critical", "standard"]),
+		epic: z.number().optional(),
+		state: z.enum([
+			"walked-pass",
+			"walked-fail",
+			"deferred",
+			"unclaimed",
+			"unwalked"
+		]),
+		ownerStories: z.array(z.string())
+	})).optional(),
 	generation: z.number().int().nonnegative(),
 	created_at: z.string(),
 	updated_at: z.string()
@@ -6381,5 +6746,5 @@ async function resolveRunManifest(dbRoot, runId) {
 }
 
 //#endregion
-export { FindingsInjector, RunManifest, RuntimeProbeListSchema, SupervisorLock, ZERO_FINDINGS_BY_AUTHOR, ZERO_FINDING_COUNTS, ZERO_PROBE_AUTHOR_METRICS, aggregateProbeAuthorMetrics, applyConfigToGraph, createDefaultVerificationPipeline, createGraphOrchestrator, createSdlcCodeReviewHandler, createSdlcCreateStoryHandler, createSdlcDevStoryHandler, createSdlcPhaseHandler, detectsEventDrivenAC, detectsStateIntegratingAC, extractTargetFilesFromStoryContent, parseRuntimeProbes, readCurrentRunId, renderFindings, resolveGraphPath, resolveMainRepoRoot, resolveRunManifest, rollupFindingCounts, rollupFindingsByAuthor, rollupProbeAuthorByClass, rollupProbeAuthorMetrics, runAcTraceabilityCheck, runStaleVerificationRecovery };
-//# sourceMappingURL=manifest-read-BhNRIiqm.js.map
+export { FindingsInjector, JOURNEY_DEFERRALS_PATH, JOURNEY_REGISTRY_PATH, RunManifest, RuntimeProbeListSchema, SupervisorLock, ZERO_FINDINGS_BY_AUTHOR, ZERO_FINDING_COUNTS, ZERO_PROBE_AUTHOR_METRICS, aggregateProbeAuthorMetrics, applyConfigToGraph, computeJourneyCoverage, createDefaultVerificationPipeline, createGraphOrchestrator, createSdlcCodeReviewHandler, createSdlcCreateStoryHandler, createSdlcDevStoryHandler, createSdlcPhaseHandler, detectsEventDrivenAC, detectsStateIntegratingAC, extractTargetFilesFromStoryContent, loadJourneyDeferralsFromTrustedTree, loadJourneyRegistryFromFile, loadJourneyRegistryFromTrustedTree, parseJourneyDeferrals, parseRuntimeProbes, parseStoryFrontmatter, readCurrentRunId, renderFindings, resolveGraphPath, resolveMainRepoRoot, resolveRunManifest, rollupFindingCounts, rollupFindingsByAuthor, rollupProbeAuthorByClass, rollupProbeAuthorMetrics, runAcTraceabilityCheck, runStaleVerificationRecovery, summarizeCoverage };
+//# sourceMappingURL=manifest-read-B3gE46DX.js.map

package/dist/modules/interactive-prompt/index.js

@@ -1,6 +1,6 @@
 import "../../logger-KeHncl-f.js";
-import "../../dist-BkhYgJWo.js";
-import "../../manifest-read-BhNRIiqm.js";
-import { runInteractivePrompt } from "../../interactive-prompt-BBfPSxyJ.js";
+import "../../dist-CpnLJuVw.js";
+import "../../manifest-read-B3gE46DX.js";
+import { runInteractivePrompt } from "../../interactive-prompt-BM5RaXYG.js";
 
 export { runInteractivePrompt };

package/dist/{routing-BS-Q8_2L.js → routing-CGO2UZyA.js}

@@ -1,4 +1,4 @@
-import { ModelRoutingConfigSchema, ProviderPolicySchema, RoutingConfigError, RoutingRecommender, RoutingResolver, RoutingTelemetry, RoutingTokenAccumulator, RoutingTuner, TASK_TYPE_PHASE_MAP, getModelTier, loadModelRoutingConfig } from "./dist-BkhYgJWo.js";
+import { ModelRoutingConfigSchema, ProviderPolicySchema, RoutingConfigError, RoutingRecommender, RoutingResolver, RoutingTelemetry, RoutingTokenAccumulator, RoutingTuner, TASK_TYPE_PHASE_MAP, getModelTier, loadModelRoutingConfig } from "./dist-CpnLJuVw.js";
 import "./routing-DFxoKHDt.js";
 
 export { loadModelRoutingConfig };

package/dist/{run-CKM-5T34.js → run-ChZFveqv.js}

@@ -1,14 +1,14 @@
-import "./health-Cfkv6XoQ.js";
+import "./health-Dnzblihr.js";
 import "./logger-KeHncl-f.js";
 import "./helpers-CElYrONe.js";
-import "./dist-BkhYgJWo.js";
-import "./manifest-read-BhNRIiqm.js";
-import { normalizeGraphSummaryToStatus, registerRunCommand, resolveMaxReviewCycles, resolveProbeAuthorStateIntegrating, runRunAction, wireNdjsonEmitter } from "./run-JrEnvaB0.js";
+import "./dist-CpnLJuVw.js";
+import "./manifest-read-B3gE46DX.js";
+import { normalizeGraphSummaryToStatus, registerRunCommand, resolveMaxReviewCycles, resolveProbeAuthorStateIntegrating, runRunAction, wireNdjsonEmitter } from "./run-ZxFHQyE_.js";
 import "./routing-DFxoKHDt.js";
 import "./work-graph-repository-DZyJv5pV.js";
 import "./decisions-CzSIEeGP.js";
 import "./decision-router-BAPpON_C.js";
-import "./interactive-prompt-BBfPSxyJ.js";
+import "./interactive-prompt-BM5RaXYG.js";
 import "./recovery-engine-BKGBeBnW.js";
 
 export { runRunAction };