@wrenai/genbi 0.0.4 → 0.0.6

package/dist-server/harness/setup/runner.js

@@ -61,6 +61,7 @@ import { buildUniformTierBinding } from "../route/tier-binding.js";
 import { createNativeToolRegistry, createSetupExecutionTool, SETUP_EXECUTION_TOOL_NAME } from "../tools/index.js";
 import { withResolvedTools } from "../tools/wiring.js";
 import { CodexSetupEventMapper } from "./codex-events.js";
+import { readYamlScalarField } from "./yaml-scalar.js";
 /** The warble component the setup wizard's connect step dispatches. */
 export const CONNECT_SOURCE_AGENT_ID = "connect_source";
 /** The Warble component the setup wizard's context step dispatches (`profiles/genbi-setup/components/build_context`). */
@@ -123,6 +124,22 @@ function resolveDispatchedUserProject(runOptions, agentId) {
     }
     return canonicalProject;
 }
+/**
+ * The project directory a project-bound step (`connect_resume`/`context`) runs
+ * against, as the default exec cwd of the in-process `setup_execution` tool.
+ * `undefined` for the initial `connect` step, which scaffolds the project from
+ * the workspace root, and for a missing/unsafe project name. The tool applies
+ * it only while the directory actually exists.
+ */
+function boundSetupProjectDir(runOptions, agentId) {
+    const stepKey = runOptions.stepKey ?? (agentId === BUILD_CONTEXT_AGENT_ID ? "context" : "connect");
+    if (stepKey === "connect")
+        return undefined;
+    const projectName = runOptions.projectName;
+    if (projectName === undefined || !SAFE_PROJECT_NAME.test(projectName))
+        return undefined;
+    return path.resolve(runOptions.workspaceRoot, projectName);
+}
 /**
  * Dispatches a setup-wizard turn over dispatched, bypassing `route()` entirely
  * (unlike the Ask turn path) so it can perform its own, setup-specific
@@ -142,6 +159,7 @@ export class DispatchedSetupRunner {
         return resolveEffectiveMaxTurns(this.options.maxTurns, agentId);
     }
     async run(runOptions) {
+        runOptions.signal?.throwIfAborted();
         const { authChoice } = runOptions;
         const agentId = runOptions.agentId ?? CONNECT_SOURCE_AGENT_ID;
         // Only build_context needs the raised turn budget — generating an MDL is
@@ -176,6 +194,7 @@ export class DispatchedSetupRunner {
             ...(modelsConfig !== undefined ? { modelsConfig } : {}),
             ...(maxTurns !== undefined ? { maxTurns } : {}),
             ...(runOptions.onEvent !== undefined ? { onEvent: runOptions.onEvent } : {}),
+            ...(runOptions.signal !== undefined ? { signal: runOptions.signal } : {}),
             ...(runOptions.resumeSessionId !== undefined ? { resumeSessionId: runOptions.resumeSessionId } : {}),
         });
         return { finalText: result.finalText, ...(result.sessionId !== undefined ? { sessionId: result.sessionId } : {}) };
@@ -248,6 +267,7 @@ export class CodexSetupRunner {
         this.options = options;
     }
     async run(runOptions) {
+        runOptions.signal?.throwIfAborted();
         if (runOptions.authChoice.mode !== "subscription" || runOptions.authChoice.provider !== "codex") {
             throw new Error("Codex setup runner requires a Codex subscription auth choice");
         }
@@ -286,10 +306,9 @@ export class CodexSetupRunner {
             "--server-arg=--workspace-root",
             "--server-arg",
             turnRoot,
-            "--source-tool",
-            SETUP_EXECUTION_TOOL_NAME,
-            "--context-tool",
-            SETUP_EXECUTION_TOOL_NAME,
+            "--transport", "exec",
+            "--step-tool", `${agentId === CONNECT_SOURCE_AGENT_ID ? "connect" : "build"}=${SETUP_EXECUTION_TOOL_NAME}`,
+            "--require-tool", agentId === CONNECT_SOURCE_AGENT_ID ? "connect" : "build",
             "--timeout",
             String(timeoutMs),
             ...(this.options.codexBin ? ["--codex-bin", this.options.codexBin] : []),
@@ -299,7 +318,7 @@ export class CodexSetupRunner {
         emitter.emit({ kind: "run.start", mode: "B", agentId });
         const mapper = new CodexSetupEventMapper(tracePath);
         try {
-            const rawFinalText = await spawnCodexSetup(cli.command, args, mapper, emitter.emit, timeoutMs + 5_000);
+            const rawFinalText = await spawnCodexSetup(cli.command, args, mapper, emitter.emit, timeoutMs + 5_000, runOptions.signal);
             const finalText = unwrapCodexSetupEnvelope(rawFinalText, expectedProducedField);
             emitter.emit({ kind: "run.finish", status: "answer" });
             return { finalText };
@@ -325,8 +344,12 @@ function defaultCodexSetupMcpInvocation(tracePath) {
 function sanitizedCodexSetupEnvironment() {
     return Object.fromEntries(Object.entries(process.env).filter(([key, value]) => value !== undefined && !CODEX_BILLING_ENV_KEYS.has(key.toUpperCase())));
 }
-function spawnCodexSetup(command, args, mapper, emit, timeoutMs) {
+function spawnCodexSetup(command, args, mapper, emit, timeoutMs, abortSignal) {
     return new Promise((resolve, reject) => {
+        if (abortSignal?.aborted) {
+            reject(new Error("Codex setup cancelled"));
+            return;
+        }
         const child = spawn(command, [...args], {
             env: sanitizedCodexSetupEnvironment(),
             stdio: ["ignore", "pipe", "pipe"],
@@ -335,6 +358,7 @@ function spawnCodexSetup(command, args, mapper, emit, timeoutMs) {
         let stderr = "";
         let settled = false;
         let timedOut = false;
+        let cancelled = false;
         let killTimer;
         const terminate = (signal) => {
             if (child.pid !== undefined && process.platform !== "win32") {
@@ -348,7 +372,17 @@ function spawnCodexSetup(command, args, mapper, emit, timeoutMs) {
             }
             child.kill(signal);
         };
+        const cancel = () => {
+            if (settled || cancelled || timedOut)
+                return;
+            cancelled = true;
+            terminate("SIGTERM");
+            killTimer = setTimeout(() => terminate("SIGKILL"), 1_000);
+        };
+        abortSignal?.addEventListener("abort", cancel, { once: true });
         const timer = setTimeout(() => {
+            if (cancelled)
+                return;
             timedOut = true;
             terminate("SIGTERM");
             killTimer = setTimeout(() => terminate("SIGKILL"), 1_000);
@@ -365,6 +399,7 @@ function spawnCodexSetup(command, args, mapper, emit, timeoutMs) {
             catch (error) {
                 settled = true;
                 clearTimeout(timer);
+                abortSignal?.removeEventListener("abort", cancel);
                 terminate("SIGTERM");
                 killTimer = setTimeout(() => terminate("SIGKILL"), 1_000);
                 reject(error);
@@ -379,12 +414,14 @@ function spawnCodexSetup(command, args, mapper, emit, timeoutMs) {
                 return;
             settled = true;
             clearTimeout(timer);
+            abortSignal?.removeEventListener("abort", cancel);
             if (killTimer)
                 clearTimeout(killTimer);
             reject(new Error(`warble-codex-local failed to start: ${error.message}`));
         });
         child.on("close", (code, signal) => {
             clearTimeout(timer);
+            abortSignal?.removeEventListener("abort", cancel);
             lines.close();
             // Do not cancel an already-scheduled process-group SIGKILL here. The
             // direct dispatcher can exit on SIGTERM while one of its descendants
@@ -392,7 +429,10 @@ function spawnCodexSetup(command, args, mapper, emit, timeoutMs) {
             if (settled)
                 return;
             settled = true;
-            if (timedOut) {
+            if (cancelled) {
+                reject(new Error("Codex setup cancelled"));
+            }
+            else if (timedOut) {
                 reject(new Error(`warble-codex-local timed out after ${timeoutMs}ms`));
             }
             else if (code !== 0) {
@@ -483,6 +523,7 @@ export class InProcessSetupRunner {
         return resolveEffectiveMaxTurns(this.options.maxTurns, agentId);
     }
     async run(runOptions) {
+        runOptions.signal?.throwIfAborted();
         const { authChoice } = runOptions;
         const agentId = runOptions.agentId ?? CONNECT_SOURCE_AGENT_ID;
         if (authChoice.mode === "subscription") {
@@ -537,8 +578,14 @@ export class InProcessSetupRunner {
             // project-root write scope on the dispatched side.
             const policy = { readOnly: false, artifactWriteScope: "." };
             const env = createLocalExecutionEnv({ rootDir: runOptions.workspaceRoot });
+            const boundProjectDir = boundSetupProjectDir(runOptions, agentId);
             const nativeTools = createNativeToolRegistry();
-            nativeTools.register(SETUP_EXECUTION_TOOL_NAME, () => createSetupExecutionTool({ env, policy, workspaceRoot: runOptions.workspaceRoot }));
+            nativeTools.register(SETUP_EXECUTION_TOOL_NAME, () => createSetupExecutionTool({
+                env,
+                policy,
+                workspaceRoot: runOptions.workspaceRoot,
+                ...(boundProjectDir !== undefined ? { defaultExecCwd: boundProjectDir } : {}),
+            }));
             // Kept in lockstep with `effectiveMaxTurns()` above via the shared
             // `resolveEffectiveMaxTurns` helper, exactly like `DispatchedSetupRunner.run()`
             // does for its own `--max-turns` flag.
@@ -548,6 +595,7 @@ export class InProcessSetupRunner {
                 registry,
                 tools,
                 userInput: runOptions.prompt,
+                ...(runOptions.signal ? { signal: runOptions.signal } : {}),
                 onEvent: emitter.emit,
                 ...(maxSteps !== undefined ? { maxSteps } : {}),
             }));
@@ -620,7 +668,9 @@ export class InProcessSetupRunner {
  * rather than pulling in a YAML parser dependency. Matches only an unindented
  * `field:` key (so it can't be fooled by a same-named key nested under
  * another mapping), strips a single layer of surrounding quotes, and returns
- * `undefined` if the file is missing/unreadable or the field isn't present.
+ * `undefined` if the file is missing/unreadable or the field isn't present. Values
+ * are read as YAML scalars (trailing comments dropped; blank or comment-only is `""`),
+ * via `./yaml-scalar.ts`.
  */
 function readProjectYamlField(yamlPath, field) {
     let content;
@@ -630,14 +680,7 @@ function readProjectYamlField(yamlPath, field) {
     catch {
         return undefined;
     }
-    const pattern = new RegExp(`^${field}:\\s*(.+?)\\s*$`, "m");
-    const match = pattern.exec(content);
-    if (!match) {
-        return undefined;
-    }
-    const raw = match[1];
-    const unquoted = /^"(.*)"$/.exec(raw) ?? /^'(.*)'$/.exec(raw);
-    return (unquoted ? unquoted[1] : raw).trim();
+    return readYamlScalarField(content, field);
 }
 /** Parses the small KEY=value subset of a project .env file used by Wren profiles. */
 function parseDotEnv(text) {
@@ -809,7 +852,7 @@ export function contextLifecycleIdentityFingerprint(root, name, selectedSourceTy
         const declaredSourceType = readProjectYamlField(projectYml, "data_source");
         const normalizedSelectedSourceType = selectedSourceType.trim().toLowerCase();
         const normalizedDeclaredSourceType = declaredSourceType?.trim().toLowerCase();
-        if (profile === undefined || normalizedDeclaredSourceType === undefined || normalizedDeclaredSourceType !== normalizedSelectedSourceType)
+        if (!profile || normalizedDeclaredSourceType === undefined || normalizedDeclaredSourceType !== normalizedSelectedSourceType)
             return undefined;
         const connectionTargetDigest = effectiveConnectionTargetDigest(projectDir, normalizedSelectedSourceType);
         if (connectionTargetDigest === undefined)
@@ -1031,6 +1074,64 @@ const SCHEMA_INTROSPECTION_COMMANDS = [
     /\b(?:psql|mysql|sqlite3|duckdb|snowsql|clickhouse-client|trino(?:-cli)?)\b[\s\S]*(?:\s(?:-c|--command|--execute|--query)\s|\b(?:information_schema|show\s+(?:tables|columns)|describe\s+(?:table|schema)|\.tables)\b)/i,
     /\bbq\s+query\b/i,
 ];
+const CD_PREFIX = /^\s*cd\s+("[^"$`\\]*"|'[^']*'|[^\s;&|<>()$`\\'"~]+)\s*&&\s*([\s\S]*)$/;
+const STARTS_WITH_CD = /^\s*cd(?:\s|$)/;
+/**
+ * A recorded relative `cwd` resolves against the tool's own root: the workspace
+ * for the in-process tool, the project for Codex local (whose tool root is the
+ * project directory for project steps).
+ */
+function recordedCwdBase(entry, cwd, binding) {
+    return path.resolve(entry.label === CODEX_SETUP_EXECUTION_TOOL_NAME ? binding.projectDir : binding.root, cwd);
+}
+function samePath(a, b) {
+    const resolvedA = path.resolve(a);
+    const resolvedB = path.resolve(b);
+    if (resolvedA === resolvedB)
+        return true;
+    try {
+        return realpathSync(resolvedA) === realpathSync(resolvedB);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The ONE recogniser rule shared by schema discovery and the context
+ * lifecycle: a recorded command counts only as the bare command or as exactly
+ * one `cd <dir> && <cmd>` whose `<dir>` is the bound project. Returns the
+ * command to match against the per-stage patterns (the `cd` prefix stripped),
+ * or `undefined` when the shape is not recognised (another directory, a second
+ * `cd`, a dynamic or `~` directory, or no binding to verify against).
+ *
+ * `<dir>` resolves against the exec's explicit `cwd` when the entry recorded
+ * one. Otherwise the effective cwd was not recorded, so the target is accepted
+ * if it names the project from either candidate default (workspace root, the
+ * pre-binding default; or the project itself, the post-binding default). The
+ * entry already exited 0, so the `cd` really resolved to that directory.
+ */
+function projectLocalCommand(entry, command, binding) {
+    const explicitCwd = entry.input?.cwd;
+    const recordedCwd = typeof explicitCwd === "string" && explicitCwd.length > 0 ? explicitCwd : undefined;
+    if (!STARTS_WITH_CD.test(command)) {
+        if (binding === undefined || recordedCwd === undefined)
+            return command;
+        // A recorded cwd must itself be the project for a bare command to count.
+        return samePath(recordedCwdBase(entry, recordedCwd, binding), binding.projectDir) ? command : undefined;
+    }
+    if (binding === undefined)
+        return undefined;
+    const match = CD_PREFIX.exec(command);
+    if (!match)
+        return undefined;
+    const raw = match[1];
+    const dir = raw.startsWith('"') || raw.startsWith("'") ? raw.slice(1, -1) : raw;
+    const inner = match[2];
+    if (dir.length === 0 || STARTS_WITH_CD.test(inner))
+        return undefined;
+    const bases = recordedCwd !== undefined ? [recordedCwdBase(entry, recordedCwd, binding)] : [binding.root, binding.projectDir];
+    return bases.some((base) => samePath(path.resolve(base, dir), binding.projectDir)) ? inner : undefined;
+}
 /**
  * The single setup-workflow contract for recognisable schema discovery. A
  * matching command is evidence only after it completed successfully (see
@@ -1039,13 +1140,18 @@ const SCHEMA_INTROSPECTION_COMMANDS = [
  * this for both terminal acceptance and the no-introspection diagnostic,
  * rather than reimplementing the allowlist elsewhere.
  */
-export function classifyRecordedSchemaDiscovery(worklog) {
+export function classifyRecordedSchemaDiscovery(worklog, binding) {
     let failed;
     for (const entry of worklog) {
         const command = isSetupExecutionEntry(entry) ? execCommandOf(entry) : undefined;
-        if (command === undefined ||
-            !SCHEMA_DISCOVERY_EVIDENCE.test(command) ||
-            !SCHEMA_INTROSPECTION_COMMANDS.some((pattern) => pattern.test(command))) {
+        if (command === undefined)
+            continue;
+        // Without a binding (legacy callers) the matching below is unchanged; with
+        // one, a leading `cd` must satisfy the shared project-local rule.
+        const recognised = binding === undefined ? command : projectLocalCommand(entry, command, binding);
+        if (recognised === undefined ||
+            !SCHEMA_DISCOVERY_EVIDENCE.test(recognised) ||
+            !SCHEMA_INTROSPECTION_COMMANDS.some((pattern) => pattern.test(recognised))) {
             continue;
         }
         const succeeded = execSucceeded(entry);
@@ -1066,7 +1172,7 @@ const DIRECT_CONTEXT_LIFECYCLE_COMMAND = new RegExp(String.raw `^\s*(?:(?:${SHEL
  * context build`, each recorded as a successful setup execution. An artifact
  * alone or merely naming a command in the final message is not evidence.
  */
-function contextLifecycleStage(command) {
+function contextLifecycleStage(entry, command, binding) {
     // This evidence must describe the actual lifecycle invocation, rather than
     // merely mention it. `setup_execution` already supplies the project cwd as
     // a separate structured field; the only shell prefixes we accept here are
@@ -1075,7 +1181,12 @@ function contextLifecycleStage(command) {
     // command cwd to the canonical project, so this is the same project-local
     // lifecycle operation emitted by some Wren guidance. Arbitrary paths, other
     // flags, shell sequencing, quoted text, and wrappers remain unrecognized.
-    const match = DIRECT_CONTEXT_LIFECYCLE_COMMAND.exec(command);
+    // The one additional shape is a single `cd <project> &&` prefix, decided by
+    // the shared `projectLocalCommand` rule (also used for schema discovery).
+    const inner = projectLocalCommand(entry, command, binding);
+    if (inner === undefined)
+        return undefined;
+    const match = DIRECT_CONTEXT_LIFECYCLE_COMMAND.exec(inner);
     return match?.[1]?.toLowerCase();
 }
 function stageAfter(prefix) {
@@ -1090,40 +1201,55 @@ function prefixFor(stage) {
         return "discovery";
     return stage === "build" ? "validate" : "none";
 }
-function scanRecordedContextLifecycle(worklog, prior) {
+const CONTEXT_LIFECYCLE_MENTION = /\bwren\s+context\s+(validate|build)\b/i;
+function scanRecordedContextLifecycle(worklog, prior, binding) {
     let stage = stageAfter(prior);
     let completed = prior === "build";
     let outOfOrderObserved;
+    // Successful commands that mention a lifecycle command but were not
+    // recognised as one, so a failure can quote them instead of claiming the
+    // command never ran.
+    const unrecognisedMentions = [];
     for (const entry of worklog) {
         if (!isSetupExecutionEntry(entry) || execSucceeded(entry) !== true)
             continue;
         const command = execCommandOf(entry);
         if (command === undefined)
             continue;
+        const noteUnrecognised = (candidate, text) => {
+            if (contextLifecycleStage(candidate, text, binding) !== undefined)
+                return;
+            const mention = CONTEXT_LIFECYCLE_MENTION.exec(text);
+            if (mention)
+                unrecognisedMentions.push({ command: text, stage: mention[1].toLowerCase() });
+        };
         if (stage === "discovery") {
-            if (classifyRecordedSchemaDiscovery([entry]).kind === "successful") {
+            if (classifyRecordedSchemaDiscovery([entry], binding).kind === "successful") {
                 stage = "validate";
                 continue;
             }
-            if (contextLifecycleStage(command) !== undefined) {
-                outOfOrderObserved ??= `successful \`${command}\` ran before successful schema discovery`;
+            if (contextLifecycleStage(entry, command, binding) !== undefined) {
+                outOfOrderObserved ??= `successful ${quoteCommand(command)} ran before successful schema discovery`;
             }
+            noteUnrecognised(entry, command);
             continue;
         }
-        const nativeStage = contextLifecycleStage(command);
+        const nativeStage = contextLifecycleStage(entry, command, binding);
+        if (nativeStage === undefined)
+            noteUnrecognised(entry, command);
         if (stage === "validate") {
             if (nativeStage === "validate") {
                 stage = "build";
             }
             else if (nativeStage === "build") {
-                outOfOrderObserved ??= `successful \`${command}\` ran before successful \`wren context validate\``;
+                outOfOrderObserved ??= `successful ${quoteCommand(command)} ran before successful \`wren context validate\``;
             }
             continue;
         }
         if (nativeStage === "build")
             completed = true;
     }
-    return { stage, completed, outOfOrderObserved };
+    return { stage, completed, outOfOrderObserved, unrecognisedMentions };
 }
 /**
  * Returns the greatest ordered prefix proved by the supplied successful tool
@@ -1131,26 +1257,122 @@ function scanRecordedContextLifecycle(worklog, prior) {
  * call in the same attempt is out of order, so a corrective attempt can ask
  * only for the unproven suffix.
  */
-export function recordedContextLifecyclePrefix(worklog, prior = "none") {
-    const scan = scanRecordedContextLifecycle(worklog, prior);
+export function recordedContextLifecyclePrefix(worklog, prior = "none", binding) {
+    const scan = scanRecordedContextLifecycle(worklog, prior, binding);
     return scan.completed ? "build" : prefixFor(scan.stage);
 }
-export function classifyRecordedContextLifecycle(worklog, prior = "none") {
-    const { stage, completed, outOfOrderObserved } = scanRecordedContextLifecycle(worklog, prior);
+export function classifyRecordedContextLifecycle(worklog, prior = "none", binding) {
+    const { stage, completed, outOfOrderObserved, unrecognisedMentions } = scanRecordedContextLifecycle(worklog, prior, binding);
+    const wanted = stage === "validate" ? "validate" : "build";
+    const unrecognised = (unrecognisedMentions.find((mention) => mention.stage === wanted) ?? unrecognisedMentions[0])?.command;
     if (completed)
         return { kind: "successful" };
+    const withUnrecognised = unrecognised !== undefined ? { unrecognised } : {};
     if (outOfOrderObserved !== undefined)
-        return { kind: "out_of_order", observed: outOfOrderObserved };
+        return { kind: "out_of_order", observed: outOfOrderObserved, ...withUnrecognised };
     if (stage === "discovery")
         return { kind: "missing_discovery" };
-    if (stage === "validate")
-        return { kind: "validate_missing", observed: "no successful `wren context validate` followed successful schema discovery" };
-    return { kind: "build_missing", observed: "no successful `wren context build` followed successful `wren context validate`" };
+    if (stage === "validate") {
+        return { kind: "validate_missing", observed: "no recognised successful `wren context validate` followed successful schema discovery", ...withUnrecognised };
+    }
+    return { kind: "build_missing", observed: "no recognised successful `wren context build` followed successful `wren context validate`", ...withUnrecognised };
 }
 /** A narrow terminal-message check: only override a context error that explicitly claims a zero-table/model outcome. */
 function claimsNoTablesOrModels(message) {
     return /\b(?:no|zero)\s+(?:tables?|models?)\b|\b0\s+(?:tables?|models?)\b/i.test(message);
 }
+const ENV_ASSIGNMENT_VALUE = /(^|[\s;&|(])([A-Za-z_][A-Za-z0-9_]*)=("[^"]*"|'[^']*'|[^\s;&|]*)/g;
+/** Masks the value of every `NAME=value` assignment (leading, after `env`, or after `&&`/`;`). */
+function redactEnvAssignments(command) {
+    return command.replace(ENV_ASSIGNMENT_VALUE, "$1$2=***");
+}
+/** Quotes a command for an error message: env values redacted first, then bounded so a long script cannot flood it. */
+function quoteCommand(command) {
+    const flat = redactEnvAssignments(command).replace(/\s+/g, " ").trim();
+    return `\`${flat.length > 300 ? `${flat.slice(0, 300)}...` : flat}\``;
+}
+const UNRECOGNISED_LIFECYCLE_HINT = "It exited successfully but is not a recognised lifecycle invocation: only the bare command (optionally with environment assignments or `--path .`) or a single `cd <project directory> &&` prefix naming this step's project directory is accepted. Run it again as the bare command and set the `setup_execution` `cwd` field to the project directory instead of shell chaining.";
+function projectBindingOf(context) {
+    return { root: context.root, projectDir: path.join(context.root, context.name) };
+}
+/**
+ * The host-held evidence gate for a successful `context` step: the recorded
+ * discovery -> validate -> build lifecycle, then the built `target/mdl.json`.
+ * Returns the failure, or `undefined` when the evidence supports success. It
+ * never looks at the agent's own status line.
+ */
+function verifyContextEvidence(context) {
+    if (context.worklog !== undefined) {
+        const lifecycle = classifyRecordedContextLifecycle(context.worklog, context.priorContextLifecycle, projectBindingOf(context));
+        if (lifecycle.kind === "missing_discovery") {
+            return hostContractFailure("context_schema_discovery_missing", "The agent never completed recognized schema discovery in its recorded worklog, so its model/build result cannot be accepted. This is an agent-workflow failure, not evidence that the connection or data source lacks tables.", "the recorded worklog has no successful recognized schema-discovery command", [
+                "run a recognized schema-discovery command against the connected source and make sure it exits successfully",
+                "build target/mdl.json only from that discovered schema, with at least one model",
+            ], "no_successful_schema_discovery");
+        }
+        const discovery = classifyRecordedSchemaDiscovery(context.worklog, projectBindingOf(context));
+        if (discovery.kind === "failed") {
+            const exitCodeSuffix = discovery.exitCode !== undefined ? ` with exit code ${discovery.exitCode}` : "";
+            return hostContractFailure("context_schema_discovery_failed", `${quoteCommand(discovery.command)} failed${exitCodeSuffix} during schema discovery — a model/build result cannot be accepted until that command/tool failure is resolved; this is not evidence that the connection or data source lacks tables.`, discovery.exitCode !== undefined
+                ? `the recorded schema-discovery command exited with code ${discovery.exitCode}`
+                : "the recorded schema-discovery command failed", [
+                "resolve the schema-discovery command failure and run a recognized discovery command successfully",
+                "build target/mdl.json only from that discovered schema, with at least one model",
+            ]);
+        }
+        if (lifecycle.kind === "validate_missing") {
+            return hostContractFailure("context_validate_missing", lifecycle.unrecognised !== undefined
+                ? `The agent ran ${quoteCommand(lifecycle.unrecognised)} successfully, but it was not recognised as \`wren context validate\` after schema discovery. ${UNRECOGNISED_LIFECYCLE_HINT}`
+                : "The agent did not successfully run `wren context validate` after recognized schema discovery, so its model/build result cannot be accepted.", lifecycle.unrecognised !== undefined
+                ? `${lifecycle.observed}; unrecognised successful command: ${quoteCommand(lifecycle.unrecognised)}`
+                : lifecycle.observed, [
+                "run a recognized schema-discovery command successfully",
+                "run `wren context validate` successfully before `wren context build`",
+                "build target/mdl.json only after validation, with at least one model",
+                ...(lifecycle.unrecognised !== undefined
+                    ? ["pass the project directory through the `setup_execution` `cwd` field rather than `cd`/shell chaining"]
+                    : []),
+            ]);
+        }
+        if (lifecycle.kind === "build_missing") {
+            return hostContractFailure("context_build_missing", lifecycle.unrecognised !== undefined
+                ? `The agent ran ${quoteCommand(lifecycle.unrecognised)} successfully, but it was not recognised as \`wren context build\` after \`wren context validate\`. ${UNRECOGNISED_LIFECYCLE_HINT}`
+                : "The agent did not successfully run `wren context build` after `wren context validate`, so its claimed context success cannot be accepted.", lifecycle.unrecognised !== undefined
+                ? `${lifecycle.observed}; unrecognised successful command: ${quoteCommand(lifecycle.unrecognised)}`
+                : lifecycle.observed, [
+                "run a recognized schema-discovery command successfully",
+                "run `wren context validate` successfully",
+                "run `wren context build` successfully after validation and produce target/mdl.json with at least one model",
+                ...(lifecycle.unrecognised !== undefined
+                    ? ["pass the project directory through the `setup_execution` `cwd` field rather than `cd`/shell chaining"]
+                    : []),
+            ]);
+        }
+        if (lifecycle.kind === "out_of_order") {
+            return hostContractFailure("context_lifecycle_out_of_order", lifecycle.unrecognised !== undefined
+                ? `The native context lifecycle ran out of order; Setup requires successful schema discovery followed by \`wren context validate\` and then \`wren context build\`. The agent also ran ${quoteCommand(lifecycle.unrecognised)} successfully, but it was not recognised. ${UNRECOGNISED_LIFECYCLE_HINT}`
+                : "The native context lifecycle ran out of order; Setup requires successful schema discovery followed by `wren context validate` and then `wren context build`.", lifecycle.unrecognised !== undefined
+                ? `${lifecycle.observed}; unrecognised successful command: ${quoteCommand(lifecycle.unrecognised)}`
+                : lifecycle.observed, [
+                "run a recognized schema-discovery command successfully",
+                "run `wren context validate` successfully before `wren context build`",
+                "produce target/mdl.json with at least one schema-derived model",
+                ...(lifecycle.unrecognised !== undefined
+                    ? ["pass the project directory through the `setup_execution` `cwd` field rather than `cd`/shell chaining"]
+                    : []),
+            ]);
+        }
+    }
+    const mdlPath = path.join(context.root, context.name, "target", "mdl.json");
+    if (!existsSync(mdlPath)) {
+        return hostContractFailure("context_mdl_missing", `the setup agent reported "ok" but ${mdlPath} does not exist — treating this as a failed context build`, "target/mdl.json is missing after the claimed context build", ["target/mdl.json must exist", "target/mdl.json must contain at least one model"]);
+    }
+    const modelCount = countMdlModels(mdlPath);
+    if (modelCount < 1) {
+        return hostContractFailure("context_mdl_empty", `the setup agent reported "ok" but ${mdlPath} has ${modelCount} models — treating this as a failed context build`, `target/mdl.json has ${modelCount} models after the claimed context build`, ["target/mdl.json must contain at least one model"]);
+    }
+    return undefined;
+}
 /**
  * Parses the LAST `SETUP_STATUS: ok|needs_input|error` line out of a setup
  * turn's finalText (the terminal contract lives in the composed
@@ -1193,6 +1415,12 @@ export function parseSetupTerminal(finalText, context) {
         }
     }
     if (!matched) {
+        // For the context step the status line is advisory: recorded execution
+        // evidence plus the built project decide success. Anything short of that
+        // keeps the missing-status failure (and its bounded correction turn).
+        if (context.stepKey === "context" && context.worklog !== undefined && verifyContextEvidence(context) === undefined) {
+            return { status: "ok", message: defaultMessageFor("ok") };
+        }
         return {
             status: "error",
             message: "the setup agent's final message did not contain a SETUP_STATUS line",
@@ -1201,54 +1429,9 @@ export function parseSetupTerminal(finalText, context) {
     }
     if (matched.status === "ok") {
         if (context.stepKey === "context") {
-            if (context.worklog !== undefined) {
-                const lifecycle = classifyRecordedContextLifecycle(context.worklog, context.priorContextLifecycle);
-                if (lifecycle.kind === "missing_discovery") {
-                    return hostContractFailure("context_schema_discovery_missing", "The agent never completed recognized schema discovery in its recorded worklog, so its model/build result cannot be accepted. This is an agent-workflow failure, not evidence that the connection or data source lacks tables.", "the recorded worklog has no successful recognized schema-discovery command", [
-                        "run a recognized schema-discovery command against the connected source and make sure it exits successfully",
-                        "build target/mdl.json only from that discovered schema, with at least one model",
-                    ], "no_successful_schema_discovery");
-                }
-                const discovery = classifyRecordedSchemaDiscovery(context.worklog);
-                if (discovery.kind === "failed") {
-                    const exitCodeSuffix = discovery.exitCode !== undefined ? ` with exit code ${discovery.exitCode}` : "";
-                    return hostContractFailure("context_schema_discovery_failed", `\`${discovery.command}\` failed${exitCodeSuffix} during schema discovery — a model/build result cannot be accepted until that command/tool failure is resolved; this is not evidence that the connection or data source lacks tables.`, discovery.exitCode !== undefined
-                        ? `the recorded schema-discovery command exited with code ${discovery.exitCode}`
-                        : "the recorded schema-discovery command failed", [
-                        "resolve the schema-discovery command failure and run a recognized discovery command successfully",
-                        "build target/mdl.json only from that discovered schema, with at least one model",
-                    ]);
-                }
-                if (lifecycle.kind === "validate_missing") {
-                    return hostContractFailure("context_validate_missing", "The agent did not successfully run `wren context validate` after recognized schema discovery, so its model/build result cannot be accepted.", lifecycle.observed, [
-                        "run a recognized schema-discovery command successfully",
-                        "run `wren context validate` successfully before `wren context build`",
-                        "build target/mdl.json only after validation, with at least one model",
-                    ]);
-                }
-                if (lifecycle.kind === "build_missing") {
-                    return hostContractFailure("context_build_missing", "The agent did not successfully run `wren context build` after `wren context validate`, so its claimed context success cannot be accepted.", lifecycle.observed, [
-                        "run a recognized schema-discovery command successfully",
-                        "run `wren context validate` successfully",
-                        "run `wren context build` successfully after validation and produce target/mdl.json with at least one model",
-                    ]);
-                }
-                if (lifecycle.kind === "out_of_order") {
-                    return hostContractFailure("context_lifecycle_out_of_order", "The native context lifecycle ran out of order; Setup requires successful schema discovery followed by `wren context validate` and then `wren context build`.", lifecycle.observed, [
-                        "run a recognized schema-discovery command successfully",
-                        "run `wren context validate` successfully before `wren context build`",
-                        "produce target/mdl.json with at least one schema-derived model",
-                    ]);
-                }
-            }
-            const mdlPath = path.join(context.root, context.name, "target", "mdl.json");
-            if (!existsSync(mdlPath)) {
-                return hostContractFailure("context_mdl_missing", `the setup agent reported "ok" but ${mdlPath} does not exist — treating this as a failed context build`, "target/mdl.json is missing after the claimed context build", ["target/mdl.json must exist", "target/mdl.json must contain at least one model"]);
-            }
-            const modelCount = countMdlModels(mdlPath);
-            if (modelCount < 1) {
-                return hostContractFailure("context_mdl_empty", `the setup agent reported "ok" but ${mdlPath} has ${modelCount} models — treating this as a failed context build`, `target/mdl.json has ${modelCount} models after the claimed context build`, ["target/mdl.json must contain at least one model"]);
-            }
+            const failure = verifyContextEvidence(context);
+            if (failure !== undefined)
+                return failure;
         }
         else {
             const markerName = context.stepKey === "connect_resume" ? ".wren-validated" : "wren_project.yml";
@@ -1295,14 +1478,14 @@ export function parseSetupTerminal(finalText, context) {
         // `setup_execution` call that exited non-zero, and reframe if one is found.
         const failedExec = firstFailedExec(context.worklog);
         if (failedExec !== undefined) {
-            const command = failedExec.command !== undefined ? `\`${failedExec.command}\`` : "a command";
+            const command = failedExec.command !== undefined ? quoteCommand(failedExec.command) : "a command";
             const exitCodeSuffix = failedExec.exitCode !== undefined ? ` with exit code ${failedExec.exitCode}` : "";
             return {
                 status: "error",
                 message: `${command} failed${exitCodeSuffix} during this step — a command in this step's own history failed, so this step's error framing can't be trusted until that's ruled out; this is a command/tool failure, not by itself evidence that the connection or data source lacks tables. The agent's own report was: "${matched.message}"`,
             };
         }
-        if (claimsNoTablesOrModels(matched.message) && classifyRecordedSchemaDiscovery(context.worklog).kind === "none") {
+        if (claimsNoTablesOrModels(matched.message) && classifyRecordedSchemaDiscovery(context.worklog, projectBindingOf(context)).kind === "none") {
             return {
                 status: "error",
                 failureKind: "no_successful_schema_discovery",

package/dist-server/harness/setup/yaml-scalar.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Reads a top-level `field: value` scalar from a `wren_project.yml`-shaped
+ * document and returns the YAML *value*, not the raw line remainder.
+ *
+ * `wren context init` scaffolds lines such as
+ * `data_source:  # not set yet — ...`, and hand-edited projects keep trailing
+ * comments (`data_source: duckdb  # change to your datasource type`). A raw
+ * remainder would hand that comment to callers as part of the value. This
+ * stays a single-purpose reader (no YAML dependency, matching the rest of
+ * `server/`); it only understands what a plain scalar line can contain:
+ *
+ * - an unquoted value ends at the first ` #` (a `#` preceded by whitespace);
+ * - a quoted value ends at its closing quote, so `"a#b"` stays `a#b` and
+ *   anything after the closing quote is a comment;
+ * - a blank value, or one that is only a comment, reads as `""` (unset).
+ *
+ * Double-quoted escapes are NOT unescaped (`"a\"b"` yields `a\"b`): only plain
+ * identifiers (data source types, profile names) are ever read through here.
+ * A leading BOM is ignored.
+ *
+ * Returns `undefined` only when the field's key line is absent.
+ */
+export declare function readYamlScalarField(content: string, field: string): string | undefined;