@inflexa-ai/harness 0.45.1 → 0.46.2

package/dist/tools/sandbox/skills.d.ts

@@ -13,19 +13,21 @@
  * reference. Expected outcomes are data variants — never throws on a missing
  * skill, an undeclared skill, or no matches.
  */
-export interface SkillToolsDeps {
+import { z } from "zod";
+import { type Tool } from "../define-tool.js";
+export type SkillToolsDeps = {
     /** Absolute path to the skills tree (one subdirectory per skill). */
     readonly skillsDir: string;
     /** The agent's declared skills (`meta.skills`) — the access allowlist. */
     readonly skills: readonly string[];
-}
-interface SkillMatch {
+};
+type SkillMatch = {
     readonly skill: string;
     readonly path: string;
     readonly line: number;
     readonly snippet: string;
     readonly score: number;
-}
+};
 type SkillSearchOutput = {
     status: "no_skills";
 } | {
@@ -59,14 +61,16 @@ type SkillReadOutput = {
     path: string;
     content: string;
 };
+declare const SkillSearchInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    topK: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const SkillReadInputSchema: z.ZodObject<{
+    skill: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strip>;
 export declare function createSkillTools(deps: SkillToolsDeps): {
-    skillSearch: import("../define-tool.js").Tool<{
-        query: string;
-        topK?: number | undefined;
-    }, SkillSearchOutput>;
-    skillRead: import("../define-tool.js").Tool<{
-        skill: string;
-        path: string;
-    }, SkillReadOutput>;
+    skillSearch: Tool<z.infer<typeof SkillSearchInputSchema>, SkillSearchOutput>;
+    skillRead: Tool<z.infer<typeof SkillReadInputSchema>, SkillReadOutput>;
 };
 export {};

package/dist/tools/sandbox/skills.js

@@ -18,12 +18,14 @@ import { join, relative, resolve, sep } from "node:path";
 import { ok } from "neverthrow";
 import { z } from "zod";
 import { defineTool } from "../define-tool.js";
+import { collapseWhitespace, splitLines } from "../../lib/text.js";
 /** Bounds — keep a search over a deep skill tree cheap and context-safe. */
 const MAX_FILE_BYTES = 512 * 1024;
 const MAX_SNIPPET = 240;
 const DEFAULT_TOP_K = 10;
 const MAX_TOP_K = 25;
-const TEXT_EXT = /\.(md|markdown|txt|py|r|R|json|ya?ml|csv|tsv)$/;
+/** The file-name extensions a skill may carry text in. */
+const TEXT_EXTENSIONS = [".md", ".markdown", ".txt", ".py", ".r", ".R", ".json", ".yaml", ".yml", ".csv", ".tsv"];
 async function collectTextFiles(dir, acc) {
     let entries;
     try {
@@ -37,11 +39,19 @@ async function collectTextFiles(dir, acc) {
         if (e.isDirectory()) {
             await collectTextFiles(full, acc);
         }
-        else if (TEXT_EXT.test(e.name)) {
+        else if (TEXT_EXTENSIONS.some((extension) => e.name.endsWith(extension))) {
             acc.push(full);
         }
     }
 }
+const SkillSearchInputSchema = z.object({
+    query: z.string().min(1).describe("Keywords to match (e.g. 'PyDESeq2 contrast syntax')."),
+    topK: z.number().int().min(1).max(MAX_TOP_K).optional().describe(`Max results to return. Defaults to ${DEFAULT_TOP_K}.`),
+});
+const SkillReadInputSchema = z.object({
+    skill: z.string().min(1).describe("Skill name (one of your declared skills)."),
+    path: z.string().min(1).describe("File path within the skill, e.g. 'SKILL.md' or 'references/pydeseq2-api.md'."),
+});
 export function createSkillTools(deps) {
     const allowed = new Set(deps.skills);
     const skillSearch = defineTool({
@@ -52,16 +62,13 @@ export function createSkillTools(deps) {
             "case-insensitive substring. Returns one entry per matching skill file — its skill, its path, " +
             "and the first line that holds a query word — ranked by how many distinct query words the file " +
             "holds. Then `skill_read` the file. No matches returns a data variant.",
-        inputSchema: z.object({
-            query: z.string().min(1).describe("Keywords to match (e.g. 'PyDESeq2 contrast syntax')."),
-            topK: z.number().int().min(1).max(MAX_TOP_K).optional().describe(`Max results to return. Defaults to ${DEFAULT_TOP_K}.`),
-        }),
+        inputSchema: SkillSearchInputSchema,
         describeCall: "none",
         execute: async ({ query, topK }) => {
             if (allowed.size === 0) {
                 return ok({ status: "no_skills" });
             }
-            const tokens = query.toLowerCase().split(/\s+/).filter(Boolean);
+            const tokens = collapseWhitespace(query.toLowerCase()).split(" ").filter(Boolean);
             const matches = [];
             for (const skill of allowed) {
                 const skillRoot = resolve(deps.skillsDir, skill);
@@ -82,7 +89,7 @@ export function createSkillTools(deps) {
                     const distinct = tokens.filter((t) => lower.includes(t)).length;
                     if (distinct === 0)
                         continue;
-                    const lines = content.split(/\r?\n/);
+                    const lines = splitLines(content);
                     const hitIdx = lines.findIndex((l) => {
                         const ll = l.toLowerCase();
                         return tokens.some((t) => ll.includes(t));
@@ -113,10 +120,7 @@ export function createSkillTools(deps) {
         description: "Read a file from one of your skills (e.g. its SKILL.md or a reference " +
             "found via skill_search). Confined to your declared skills. Undeclared " +
             "skills and missing paths return a data variant.",
-        inputSchema: z.object({
-            skill: z.string().min(1).describe("Skill name (one of your declared skills)."),
-            path: z.string().min(1).describe("File path within the skill, e.g. 'SKILL.md' or 'references/pydeseq2-api.md'."),
-        }),
+        inputSchema: SkillReadInputSchema,
         describeCall: "none",
         execute: async ({ skill, path }) => {
             if (!allowed.has(skill)) {

package/dist/tools/sandbox/submit-file-metadata.d.ts

@@ -10,21 +10,24 @@
  * index, so a dropped, reordered, or extra entry can never attach a
  * description to the wrong file.
  */
-import { type SubmittedFileDescription } from "../../schemas/file-metadata.js";
 import { type Tool } from "../define-tool.js";
 export declare const SUBMIT_FILE_METADATA_TOOL_ID = "submit_file_metadata";
 /**
- * The per-step cell of the file-metadata continuation. The step body makes it
- * beside the blocker cell, and the agent factory binds the output tool to it.
+ * The per-step cell of the file-metadata follow-up request. The step body makes
+ * it beside the step agent, and the agent factory binds the output tool to it.
+ * The descriptions themselves live in the inputs of the calls: the post-step
+ * code reads them from the recorded calls.
  */
-export interface FileMetadataCell {
-    /** The paths that the continuation describes, or `null` before the first `expect`. */
+export type FileMetadataCell = {
+    /** The paths that the follow-up request describes, or `null` before the first `expect`. */
     readonly knownPaths: ReadonlySet<string> | null;
-    /** The accepted description of each described path, keyed by the path. The tool writes only a known path. */
-    readonly descriptions: Map<string, SubmittedFileDescription>;
-    /** Arm the cell for one continuation: set the known paths, and drop each accepted description. */
+    /** The known paths that the earlier calls described. The loop folds each call record into it. */
+    readonly described: ReadonlySet<string>;
+    /** Arm the cell for one follow-up request: set the known paths, and forget each described path. */
     expect(paths: readonly string[]): void;
-}
+    /** Add the paths of one call record. */
+    fold(paths: readonly string[]): void;
+};
 export declare function createFileMetadataCell(): FileMetadataCell;
 /** Build the `submit_file_metadata` tool bound to the cell of one step. */
 export declare function createSubmitFileMetadataTool(cell: FileMetadataCell): Tool;

package/dist/tools/sandbox/submit-file-metadata.js

@@ -12,19 +12,23 @@
  */
 import { err, ok } from "neverthrow";
 import { SubmitFileMetadataInputSchema } from "../../schemas/file-metadata.js";
-import { defineTool } from "../define-tool.js";
+import { defineTool, withToolCallRecord } from "../define-tool.js";
 export const SUBMIT_FILE_METADATA_TOOL_ID = "submit_file_metadata";
 export function createFileMetadataCell() {
     let knownPaths = null;
-    const descriptions = new Map();
+    const described = new Set();
     return {
         get knownPaths() {
             return knownPaths;
         },
-        descriptions,
+        described,
         expect(paths) {
             knownPaths = new Set(paths);
-            descriptions.clear();
+            described.clear();
+        },
+        fold(paths) {
+            for (const path of paths)
+                described.add(path);
         },
     };
 }
@@ -40,28 +44,21 @@ export function createSubmitFileMetadataTool(cell) {
             "the unknownPaths and describe the remaining files.",
         inputSchema: SubmitFileMetadataInputSchema,
         describeCall: "none",
-        execute: async (input) => {
+        execute: (input) => {
             const knownPaths = cell.knownPaths;
             if (knownPaths === null) {
-                return err({
+                return Promise.resolve(err({
                     error: "No list of files is known yet. The harness asks for the file metadata after the task, with the list of the files.",
                     retryable: false,
-                });
-            }
-            const unknownPaths = [];
-            for (const entry of input.files) {
-                if (!knownPaths.has(entry.path)) {
-                    unknownPaths.push(entry.path);
-                    continue;
-                }
-                cell.descriptions.set(entry.path, entry);
+                }));
             }
-            const remaining = [...knownPaths].filter((path) => !cell.descriptions.has(path));
-            return ok({
-                accepted: unknownPaths.length === 0 && remaining.length === 0,
-                unknownPaths,
-                remaining,
-            });
+            const unknownPaths = input.files.map((entry) => entry.path).filter((path) => !knownPaths.has(path));
+            const described = input.files.map((entry) => entry.path).filter((path) => knownPaths.has(path));
+            const covered = new Set([...cell.described, ...described]);
+            const remaining = [...knownPaths].filter((path) => !covered.has(path));
+            const outcome = { accepted: unknownPaths.length === 0 && remaining.length === 0, unknownPaths, remaining };
+            return Promise.resolve(ok(withToolCallRecord(outcome, { described })));
         },
+        foldCallRecord: (record) => cell.fold(record.described),
     });
 }

package/dist/tools/start-report-session.d.ts

@@ -12,17 +12,23 @@
  * past the anchor of the newest report child, the tool starts nothing and it
  * names that child. The spawn runs last.
  *
+ * Inside a durable step, the child id is the UUIDv5 of the key of the step. A
+ * rerun of the call after the spawn, before the checkpoint of the step, finds
+ * that child. It skips the advice, and it gives the same session and the same
+ * part.
+ *
  * Each degraded condition is a typed outcome in the ok channel: a scope with no
  * thread id, a composition with no eyes, the advice, each refusal of the spawn,
  * and a store fault. The tool never throws for one of them.
  */
-import type { Pool } from "pg";
+import type { Querier } from "../state/db.js";
 import { z } from "zod";
 import type { EnsureSessionStateResult } from "../app/report-session-runtime.js";
 import type { ChromeConfig } from "../lib/chrome.js";
+import { type Connectable } from "../lib/db-result.js";
 import type { AcquireEyes } from "../lib/eyes.js";
 import type { Logger } from "../lib/logger.js";
-import type { ThreadType } from "../memory/thread-store.js";
+import { type ThreadType } from "../memory/thread-store.js";
 import { type Tool } from "./define-tool.js";
 import type { ProvenanceSeam } from "../provenance/seam.js";
 /**
@@ -85,8 +91,8 @@ export type StartReportSessionResult = {
  * a page. A composition that binds a capture seam straight to the spawn still
  * opens the gate of that spawn.
  */
-export interface StartReportSessionToolDeps {
-    readonly pool: Pool;
+export type StartReportSessionToolDeps = {
+    readonly pool: Querier & Connectable;
     readonly chrome: ChromeConfig;
     /**
      * The eyes seam of the composition. A bound seam gives a browser for one
@@ -107,7 +113,9 @@ export interface StartReportSessionToolDeps {
      */
     readonly provenance?: ProvenanceSeam;
     readonly logger?: Logger;
-}
+    /** The key of the durable step that runs the call, `undefined` outside one. Defaults to {@link durableStepKey}. */
+    readonly stepKey?: () => string | undefined;
+};
 /**
  * Make the tool that starts a report session, over one Postgres pool and the
  * eyes of the composition.

package/dist/tools/start-report-session.js

@@ -12,6 +12,11 @@
  * past the anchor of the newest report child, the tool starts nothing and it
  * names that child. The spawn runs last.
  *
+ * Inside a durable step, the child id is the UUIDv5 of the key of the step. A
+ * rerun of the call after the spawn, before the checkpoint of the step, finds
+ * that child. It skips the advice, and it gives the same session and the same
+ * part.
+ *
  * Each degraded condition is a typed outcome in the ok channel: a scope with no
  * thread id, a composition with no eyes, the advice, each refusal of the spawn,
  * and a store fault. The tool never throws for one of them.
@@ -21,7 +26,9 @@ import { z } from "zod";
 import { compositionHasEyes, createReportSessionSpawn } from "../app/spawn-report-session.js";
 import { createNoopLogger } from "../lib/console-logger.js";
 import { describeDbError } from "../lib/db-result.js";
+import { createThreadStore } from "../memory/thread-store.js";
 import { defineTool } from "./define-tool.js";
+import { durableStepKey, stepUuid } from "./workspace/edit-file.js";
 /**
  * The character bound of each brief field. The whole brief lands in one durable
  * message row, thus the schema holds no unbounded string out of the store.
@@ -107,12 +114,14 @@ export function createStartReportSessionTool(deps) {
     const spawnDeps = {
         pool: deps.pool,
         chrome: deps.chrome,
-        ...(deps.eyes ? { eyes: deps.eyes } : {}),
-        ...(deps.anchorSession ? { anchorSession: deps.anchorSession } : {}),
-        ...(deps.provenance ? { provenance: deps.provenance } : {}),
-        ...(deps.logger ? { logger: deps.logger } : {}),
+        eyes: deps.eyes,
+        anchorSession: deps.anchorSession,
+        provenance: deps.provenance,
+        logger: deps.logger,
     };
     const spawn = createReportSessionSpawn(spawnDeps);
+    const threads = createThreadStore(deps.pool);
+    const stepKey = deps.stepKey ?? durableStepKey;
     // The gate reads the routes of the very spawn below, thus the two answers
     // come from one value. The routes are fixed at construction, thus the gate
     // reads one boolean and never a live probe of the sidecar.
@@ -132,7 +141,6 @@ export function createStartReportSessionTool(deps) {
             "`no_browser` means that this deployment has no browser for the report agent, thus no report session can start; tell the user. " +
             "`refused`, `parent_not_found`, `parent_not_a_conversation`, and `failed` mean that nothing started, and `detail` gives the reason where there is one.",
         inputSchema: startReportSessionInput,
-        executionMode: "inline",
         describeCall: "none",
         execute: async (input, ctx) => {
             const brief = {
@@ -143,16 +151,35 @@ export function createStartReportSessionTool(deps) {
                 openQuestions: input.openQuestions,
             };
             const { scope } = ctx.session;
-            if (scope.kind !== "analysis" || scope.threadId === undefined || scope.threadId.length === 0) {
+            if (scope.threadId === undefined || scope.threadId.length === 0) {
                 return ok({ outcome: "refused", detail: NO_THREAD_SCOPE_DETAIL });
             }
             const parentThreadId = scope.threadId;
+            // Inside a durable step the child id comes from the step, thus a rerun of
+            // the call finds the child of its first run. The advice would name that
+            // child as an existing session, thus a found child skips the advice, and
+            // the spawn gives the child back with no second write.
+            const key = stepKey();
+            const childThreadId = key === undefined ? undefined : stepUuid(key);
+            let rerun = false;
+            if (childThreadId !== undefined) {
+                const earlier = await threads.getThread(childThreadId);
+                if (earlier.isErr()) {
+                    logger.warn("the child of an earlier run did not read", {
+                        parentThreadId,
+                        reason: earlier.error.type,
+                        ...logger.errorFields(earlier.error.cause),
+                    });
+                    return ok(toOutcome(earlier.error));
+                }
+                rerun = earlier.value !== null;
+            }
             // The eyes gate has priority over the advice, and the advice costs two
             // reads. The spawn holds the same gate before each read of its own,
             // thus a blind composition reaches the `no_browser` refusal of the
             // spawn with no read and no write. As a result the tool copies no
             // detail line of the spawn.
-            if (eyesAvailable) {
+            if (eyesAvailable && !rerun) {
                 const delta = await spawn.reportSessionDelta(parentThreadId);
                 if (delta.isErr()) {
                     logger.warn("the report session delta did not read", {
@@ -172,7 +199,7 @@ export function createStartReportSessionTool(deps) {
                     return ok({ outcome: "existing-session", threadId: newestChild.threadId, title: newestChild.title });
                 }
             }
-            const spawned = await spawn.spawnReportSession(parentThreadId, brief);
+            const spawned = await spawn.spawnReportSession(parentThreadId, brief, childThreadId);
             if (spawned.isOk()) {
                 const child = spawned.value;
                 // The part rides the started arm only. The existing-session arm

package/dist/tools/terminal-text.d.ts

@@ -3,9 +3,12 @@
  *
  * A terminal call whose text is a placeholder ends a run with nothing. A small
  * model emits such a call when it drafts several calls at once and fills the
- * text later, or never. The guard names the fault, the tool refuses the call,
- * and the loop continues with the real work.
+ * text later, or never. The input schema of the tool names the fault, the call
+ * gets an error result, and the loop continues with the real work.
  */
+import { z } from "zod";
 export declare const MIN_TERMINAL_TEXT = 4;
 /** The reason a text cannot end a run, or undefined when it can. */
 export declare function degenerateTerminalText(text: string): string | undefined;
+/** The text of a terminal call. The schema refuses a placeholder, and the issue says what to do instead. */
+export declare function terminalTextSchema(description: string): z.ZodString;

package/dist/tools/terminal-text.js

@@ -3,9 +3,11 @@
  *
  * A terminal call whose text is a placeholder ends a run with nothing. A small
  * model emits such a call when it drafts several calls at once and fills the
- * text later, or never. The guard names the fault, the tool refuses the call,
- * and the loop continues with the real work.
+ * text later, or never. The input schema of the tool names the fault, the call
+ * gets an error result, and the loop continues with the real work.
  */
+import { z } from "zod";
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- the anchored placeholder words and their n/a spellings, at the start of the text; the alternation is the guard's own word list.
 const PLACEHOLDER_TEXT = /^\s*(?:placeholder|todo|tbd|skip|n\/?a|none|null|test|x+|\.+|-+)\b/i;
 export const MIN_TERMINAL_TEXT = 4;
 /** The reason a text cannot end a run, or undefined when it can. */
@@ -13,7 +15,37 @@ export function degenerateTerminalText(text) {
     const trimmed = text.trim();
     if (trimmed.length < MIN_TERMINAL_TEXT)
         return `The text has ${trimmed.length} characters, and a real question or reason has at least ${MIN_TERMINAL_TEXT}.`;
-    if (PLACEHOLDER_TEXT.test(trimmed) || /\bplaceholder\b/i.test(trimmed))
+    if (PLACEHOLDER_TEXT.test(trimmed) || holdsStandaloneWord(trimmed, "placeholder"))
         return "The text is a placeholder.";
     return undefined;
 }
+/** The text of a terminal call. The schema refuses a placeholder, and the issue says what to do instead. */
+export function terminalTextSchema(description) {
+    return z
+        .string()
+        .min(1)
+        .check(z.superRefine((text, ctx) => {
+        const degenerate = degenerateTerminalText(text);
+        if (degenerate !== undefined)
+            ctx.addIssue({ code: "custom", message: `${degenerate} Give the real text, or continue the work.` });
+    }))
+        .describe(description);
+}
+/** Whether `word` occurs in `text` as a standalone word, case-insensitively. */
+function holdsStandaloneWord(text, word) {
+    const lower = text.toLowerCase();
+    const needle = word.toLowerCase();
+    let at = lower.indexOf(needle);
+    while (at >= 0) {
+        const boundedBefore = at === 0 || !isWordChar(lower.charAt(at - 1));
+        const end = at + needle.length;
+        const boundedAfter = end >= lower.length || !isWordChar(lower.charAt(end));
+        if (boundedBefore && boundedAfter)
+            return true;
+        at = lower.indexOf(needle, at + 1);
+    }
+    return false;
+}
+function isWordChar(char) {
+    return (char >= "a" && char <= "z") || (char >= "A" && char <= "Z") || (char >= "0" && char <= "9") || char === "_";
+}

package/dist/tools/workspace/decision-record.d.ts

@@ -27,15 +27,15 @@ export declare function decisionRecordPath(scriptFile: string): string;
 export declare function decisionRecordPathFor(scriptPath: string): string | undefined;
 export declare function scriptSha256(content: string | Uint8Array): string;
 /** One change of a script after its render, as the record keeps it. */
-export interface UnvettedEdit {
+export type UnvettedEdit = {
     readonly path: string;
     readonly note: string;
     /** The digest of the script after the change. */
     readonly sha256: string;
-}
+};
 /** The digest the record expects of the script now: the last recorded change, else the bytes the render wrote. */
 export declare function expectedScriptSha256(record: Readonly<Record<string, unknown>>): string | undefined;
-export interface NoteScriptChangeArgs {
+export type NoteScriptChangeArgs = {
     readonly filesystem: WorkspaceFilesystem;
     readonly mutator: WorkspaceMutator;
     readonly session: AgentSession;
@@ -49,7 +49,7 @@ export interface NoteScriptChangeArgs {
     readonly note: string;
     /** The digest of the script after the change. */
     readonly sha256: string;
-}
+};
 /**
  * The outcome of a change note. `noted` carries the record of the write,
  * thus the calling tool carries it as its call record, and its fold hands it

package/dist/tools/workspace/decision-record.js

@@ -11,14 +11,23 @@
  */
 import { createHash } from "node:crypto";
 import { posix as posixPath } from "node:path";
+import { z } from "zod";
 import { unwrapOrThrow } from "../../lib/result.js";
+import { safeParseJsonAs } from "../../lib/parse-json.js";
+import { isUnknownArray } from "../../lib/unknown-array.js";
+import { UnknownRecordSchema } from "../../lib/unknown-containers.js";
 /**
  * The path of the decision record of one rendered script inside the step:
  * `output/decision_record_<script stem>.json`. One record per render, thus a
  * step that renders two scripts keeps both records.
  */
 export function decisionRecordPath(scriptFile) {
-    const stem = scriptFile.replace(/\.[A-Za-z0-9]+$/, "");
+    const dot = scriptFile.lastIndexOf(".");
+    const suffix = scriptFile.slice(dot + 1);
+    const isSuffixAlnum = dot !== -1 &&
+        suffix.length > 0 &&
+        Array.from(suffix).every((char) => (char >= "a" && char <= "z") || (char >= "A" && char <= "Z") || (char >= "0" && char <= "9"));
+    const stem = isSuffixAlnum ? scriptFile.slice(0, dot) : scriptFile;
     return `output/decision_record_${stem}.json`;
 }
 /**
@@ -37,12 +46,13 @@ export function decisionRecordPathFor(scriptPath) {
 export function scriptSha256(content) {
     return `sha256:${createHash("sha256").update(content).digest("hex")}`;
 }
+const LastEditRecordSchema = z.looseObject({ sha256: z.string() });
 /** The digest the record expects of the script now: the last recorded change, else the bytes the render wrote. */
 export function expectedScriptSha256(record) {
-    const edits = Array.isArray(record.unvetted_edits) ? record.unvetted_edits : [];
-    const last = edits[edits.length - 1]?.sha256;
-    if (typeof last === "string")
-        return last;
+    const edits = isUnknownArray(record.unvetted_edits) ? record.unvetted_edits : [];
+    const parsed = LastEditRecordSchema.safeParse(edits.at(-1));
+    if (parsed.success)
+        return parsed.data.sha256;
     return typeof record.written_sha256 === "string" ? record.written_sha256 : undefined;
 }
 /**
@@ -56,20 +66,20 @@ export async function noteScriptChange(args) {
     const recordPath = decisionRecordPathFor(args.scriptPath);
     if (!recordPath)
         return { status: "no_record" };
-    const read = unwrapOrThrow(await args.filesystem.readFile({ session: args.session, path: recordPath, ...(args.workingDir !== undefined ? { workingDir: args.workingDir } : {}) }));
+    const read = unwrapOrThrow(await args.filesystem.readFile({ session: args.session, path: recordPath, workingDir: args.workingDir }));
     if (read.kind !== "ok")
         return { status: "no_record" };
     let record;
     try {
-        const parsed = JSON.parse(read.content.toString("utf8"));
-        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        const parsed = safeParseJsonAs(read.content.toString("utf8"), UnknownRecordSchema);
+        if (!parsed.success)
             return { status: "no_record" };
-        record = parsed;
+        record = parsed.data;
     }
     catch {
         return { status: "no_record" };
     }
-    const edits = Array.isArray(record.unvetted_edits) ? record.unvetted_edits : [];
+    const edits = isUnknownArray(record.unvetted_edits) ? record.unvetted_edits : [];
     const entry = { path: args.scriptPath, note: args.note, sha256: args.sha256 };
     const next = { ...record, unvetted_edits: [...edits, entry] };
     const written = await args.mutator.writeFile({
@@ -97,10 +107,10 @@ export async function reconcileScriptRecord(args) {
         return { status: "no_record" };
     let expected;
     try {
-        const parsed = JSON.parse(record.content.toString("utf8"));
-        if (parsed === null || typeof parsed !== "object")
+        const parsed = safeParseJsonAs(record.content.toString("utf8"), UnknownRecordSchema);
+        if (!parsed.success)
             return { status: "no_record" };
-        expected = expectedScriptSha256(parsed);
+        expected = expectedScriptSha256(parsed.data);
     }
     catch {
         return { status: "no_record" };