@reticlehq/server 3.7.0 → 3.8.1

package/dist/memory/intent/intent-shard.d.ts

@@ -43,111 +43,39 @@ export type IntentStatus = (typeof IntentStatus)[keyof typeof IntentStatus];
 declare const IntentRecordSchema: z.ZodObject<{
     id: z.ZodString;
     statement: z.ZodString;
-    state: z.ZodEnum<["declared", "bound", "proved"]>;
+    state: z.ZodEnum<{
+        proved: "proved";
+        declared: "declared";
+        bound: "bound";
+    }>;
     declaredAt: z.ZodNumber;
     binding: z.ZodOptional<z.ZodUnknown>;
     surface: z.ZodOptional<z.ZodObject<{
         route: z.ZodOptional<z.ZodString>;
         flow: z.ZodOptional<z.ZodString>;
-        files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        route?: string | undefined;
-        flow?: string | undefined;
-        files?: string[] | undefined;
-    }, {
-        route?: string | undefined;
-        flow?: string | undefined;
-        files?: string[] | undefined;
-    }>>;
+        files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
     provenBy: z.ZodOptional<z.ZodObject<{
         verdictId: z.ZodString;
         grade: z.ZodString;
         at: z.ZodNumber;
         runId: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        at: number;
-        grade: string;
-        verdictId: string;
-        runId?: string | undefined;
-    }, {
-        at: number;
-        grade: string;
-        verdictId: string;
-        runId?: string | undefined;
-    }>>;
+    }, z.core.$strip>>;
     amended: z.ZodOptional<z.ZodArray<z.ZodObject<{
         statement: z.ZodString;
         at: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        at: number;
-        statement: string;
-    }, {
-        at: number;
-        statement: string;
-    }>, "many">>;
-} & {
-    /** Which shard this lives in. Stored as well as implied, so a file read alone is self-describing. */
+    }, z.core.$strip>>>;
     subject: z.ZodString;
-    status: z.ZodEnum<["proposed", "agreed", "proved", "stale"]>;
-    /** WHY it must be true. The half the old file had no room for. */
+    status: z.ZodEnum<{
+        proved: "proved";
+        proposed: "proposed";
+        agreed: "agreed";
+        stale: "stale";
+    }>;
     why: z.ZodOptional<z.ZodString>;
-    /** Where it came from — "the user, in conversation" beats an anonymous assertion in six months. */
     source: z.ZodOptional<z.ZodString>;
-    /** When it was last touched, so a stale-looking record can be told from an untouched one. */
     updatedAt: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    status: "proved" | "proposed" | "agreed" | "stale";
-    state: "proved" | "declared" | "bound";
-    id: string;
-    subject: string;
-    statement: string;
-    declaredAt: number;
-    surface?: {
-        route?: string | undefined;
-        flow?: string | undefined;
-        files?: string[] | undefined;
-    } | undefined;
-    source?: string | undefined;
-    why?: string | undefined;
-    updatedAt?: number | undefined;
-    binding?: unknown;
-    provenBy?: {
-        at: number;
-        grade: string;
-        verdictId: string;
-        runId?: string | undefined;
-    } | undefined;
-    amended?: {
-        at: number;
-        statement: string;
-    }[] | undefined;
-}, {
-    status: "proved" | "proposed" | "agreed" | "stale";
-    state: "proved" | "declared" | "bound";
-    id: string;
-    subject: string;
-    statement: string;
-    declaredAt: number;
-    surface?: {
-        route?: string | undefined;
-        flow?: string | undefined;
-        files?: string[] | undefined;
-    } | undefined;
-    source?: string | undefined;
-    why?: string | undefined;
-    updatedAt?: number | undefined;
-    binding?: unknown;
-    provenBy?: {
-        at: number;
-        grade: string;
-        verdictId: string;
-        runId?: string | undefined;
-    } | undefined;
-    amended?: {
-        at: number;
-        statement: string;
-    }[] | undefined;
-}>;
+}, z.core.$strip>;
 export type IntentRecord = z.infer<typeof IntentRecordSchema>;
 export declare const IntentShardSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
@@ -155,172 +83,40 @@ export declare const IntentShardSchema: z.ZodObject<{
     intents: z.ZodRecord<z.ZodString, z.ZodObject<{
         id: z.ZodString;
         statement: z.ZodString;
-        state: z.ZodEnum<["declared", "bound", "proved"]>;
+        state: z.ZodEnum<{
+            proved: "proved";
+            declared: "declared";
+            bound: "bound";
+        }>;
         declaredAt: z.ZodNumber;
         binding: z.ZodOptional<z.ZodUnknown>;
         surface: z.ZodOptional<z.ZodObject<{
             route: z.ZodOptional<z.ZodString>;
             flow: z.ZodOptional<z.ZodString>;
-            files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        }, "strip", z.ZodTypeAny, {
-            route?: string | undefined;
-            flow?: string | undefined;
-            files?: string[] | undefined;
-        }, {
-            route?: string | undefined;
-            flow?: string | undefined;
-            files?: string[] | undefined;
-        }>>;
+            files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
         provenBy: z.ZodOptional<z.ZodObject<{
             verdictId: z.ZodString;
             grade: z.ZodString;
             at: z.ZodNumber;
             runId: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            at: number;
-            grade: string;
-            verdictId: string;
-            runId?: string | undefined;
-        }, {
-            at: number;
-            grade: string;
-            verdictId: string;
-            runId?: string | undefined;
-        }>>;
+        }, z.core.$strip>>;
         amended: z.ZodOptional<z.ZodArray<z.ZodObject<{
             statement: z.ZodString;
             at: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            at: number;
-            statement: string;
-        }, {
-            at: number;
-            statement: string;
-        }>, "many">>;
-    } & {
-        /** Which shard this lives in. Stored as well as implied, so a file read alone is self-describing. */
+        }, z.core.$strip>>>;
         subject: z.ZodString;
-        status: z.ZodEnum<["proposed", "agreed", "proved", "stale"]>;
-        /** WHY it must be true. The half the old file had no room for. */
+        status: z.ZodEnum<{
+            proved: "proved";
+            proposed: "proposed";
+            agreed: "agreed";
+            stale: "stale";
+        }>;
         why: z.ZodOptional<z.ZodString>;
-        /** Where it came from — "the user, in conversation" beats an anonymous assertion in six months. */
         source: z.ZodOptional<z.ZodString>;
-        /** When it was last touched, so a stale-looking record can be told from an untouched one. */
         updatedAt: z.ZodOptional<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        status: "proved" | "proposed" | "agreed" | "stale";
-        state: "proved" | "declared" | "bound";
-        id: string;
-        subject: string;
-        statement: string;
-        declaredAt: number;
-        surface?: {
-            route?: string | undefined;
-            flow?: string | undefined;
-            files?: string[] | undefined;
-        } | undefined;
-        source?: string | undefined;
-        why?: string | undefined;
-        updatedAt?: number | undefined;
-        binding?: unknown;
-        provenBy?: {
-            at: number;
-            grade: string;
-            verdictId: string;
-            runId?: string | undefined;
-        } | undefined;
-        amended?: {
-            at: number;
-            statement: string;
-        }[] | undefined;
-    }, {
-        status: "proved" | "proposed" | "agreed" | "stale";
-        state: "proved" | "declared" | "bound";
-        id: string;
-        subject: string;
-        statement: string;
-        declaredAt: number;
-        surface?: {
-            route?: string | undefined;
-            flow?: string | undefined;
-            files?: string[] | undefined;
-        } | undefined;
-        source?: string | undefined;
-        why?: string | undefined;
-        updatedAt?: number | undefined;
-        binding?: unknown;
-        provenBy?: {
-            at: number;
-            grade: string;
-            verdictId: string;
-            runId?: string | undefined;
-        } | undefined;
-        amended?: {
-            at: number;
-            statement: string;
-        }[] | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    version: 1;
-    intents: Record<string, {
-        status: "proved" | "proposed" | "agreed" | "stale";
-        state: "proved" | "declared" | "bound";
-        id: string;
-        subject: string;
-        statement: string;
-        declaredAt: number;
-        surface?: {
-            route?: string | undefined;
-            flow?: string | undefined;
-            files?: string[] | undefined;
-        } | undefined;
-        source?: string | undefined;
-        why?: string | undefined;
-        updatedAt?: number | undefined;
-        binding?: unknown;
-        provenBy?: {
-            at: number;
-            grade: string;
-            verdictId: string;
-            runId?: string | undefined;
-        } | undefined;
-        amended?: {
-            at: number;
-            statement: string;
-        }[] | undefined;
-    }>;
-    subject: string;
-}, {
-    version: 1;
-    intents: Record<string, {
-        status: "proved" | "proposed" | "agreed" | "stale";
-        state: "proved" | "declared" | "bound";
-        id: string;
-        subject: string;
-        statement: string;
-        declaredAt: number;
-        surface?: {
-            route?: string | undefined;
-            flow?: string | undefined;
-            files?: string[] | undefined;
-        } | undefined;
-        source?: string | undefined;
-        why?: string | undefined;
-        updatedAt?: number | undefined;
-        binding?: unknown;
-        provenBy?: {
-            at: number;
-            grade: string;
-            verdictId: string;
-            runId?: string | undefined;
-        } | undefined;
-        amended?: {
-            at: number;
-            statement: string;
-        }[] | undefined;
-    }>;
-    subject: string;
-}>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type IntentShard = z.infer<typeof IntentShardSchema>;
 export declare const IntentIndexSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
@@ -328,35 +124,14 @@ export declare const IntentIndexSchema: z.ZodObject<{
         id: z.ZodString;
         subject: z.ZodString;
         statement: z.ZodString;
-        status: z.ZodEnum<["proposed", "agreed", "proved", "stale"]>;
-    }, "strip", z.ZodTypeAny, {
-        status: "proved" | "proposed" | "agreed" | "stale";
-        id: string;
-        subject: string;
-        statement: string;
-    }, {
-        status: "proved" | "proposed" | "agreed" | "stale";
-        id: string;
-        subject: string;
-        statement: string;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    entries: {
-        status: "proved" | "proposed" | "agreed" | "stale";
-        id: string;
-        subject: string;
-        statement: string;
-    }[];
-    version: 1;
-}, {
-    entries: {
-        status: "proved" | "proposed" | "agreed" | "stale";
-        id: string;
-        subject: string;
-        statement: string;
-    }[];
-    version: 1;
-}>;
+        status: z.ZodEnum<{
+            proved: "proved";
+            proposed: "proposed";
+            agreed: "agreed";
+            stale: "stale";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type IntentIndex = z.infer<typeof IntentIndexSchema>;
 export declare const emptyShard: (subject: string) => IntentShard;
 /** The verification lifecycle a legacy record carried, mapped onto the settledness axis. */

package/dist/memory/intent/intent-tools.js

@@ -1,14 +1,12 @@
-import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { z } from 'zod';
-import { StatementSource, classifyStatement, splitStatements, } from '@reticlehq/core/artifacts';
-import { redactFeedbackText } from '../../telemetry/feedback.js';
+import { promptContextFor, sharesRequests } from './record-request.js';
 import { reticleDirPaths } from '../project/dir/reticle-dir.js';
 import { IntentStore } from './intent-store.js';
 import { IntentShardStore } from './intent-shard-store.js';
 import { IntentStatus } from './intent-shard.js';
 import { UNSORTED_SUBJECT } from './intent-subject.js';
-import { ReticleDir, ReticleTool, apiKeyFrom } from '@reticlehq/core';
+import { ReticleTool } from '@reticlehq/core';
 import { sessionIdShape } from '../../surface/tools/tool-kit.js';
 import { PredicateSchema } from '@reticlehq/engine/question/predicate/predicate.js';
 import { sessionRoot } from '../project/session-root.js';
@@ -81,7 +79,10 @@ export const INTENT_TOOLS = [
                 .optional()
                 .describe('declare only. Batchable — declare every intent for a feature in one call.'),
             request: z.string().optional().describe("declare: the user's words, verbatim."),
-            id: z.string().optional().describe('bind only: which intent the predicate proves.'),
+            id: z
+                .string()
+                .optional()
+                .describe('bind, get and record: which intent. For bind, the intent the predicate proves.'),
             /*
              * The predicate schema, not `unknown`.
              *
@@ -136,18 +137,26 @@ export const INTENT_TOOLS = [
             const store = new IntentStore(deps.fs, root, { now: deps.now });
             const shards = new IntentShardStore(deps.fs, root, { now: deps.now });
             const action = asString(args['action']);
+            // An empty argument answered "there is none" (`null`, `[]`, `bound: false`), or a raw zod
+            // path for `record`, instead of saying which argument the call left out.
+            const need = (name) => {
+                const value = asString(args[name]);
+                if (value !== undefined && 0 < value.trim().length)
+                    return value;
+                throw new Error(`${ReticleTool.INTENT} ${String(action)}: \`${name}\` is required, and none was given — nothing was read or stored`);
+            };
             if (INDEX === action)
                 return { entries: (await shards.index()).entries, path: root };
             if (SUBJECT === action)
-                return { records: await shards.subject(asString(args['subject']) ?? ''), path: root };
+                return { records: await shards.subject(need('subject')), path: root };
             if (GET === action)
-                return { record: await shards.get(asString(args['id']) ?? '') };
+                return { record: await shards.get(need('id')) };
             if (MIGRATE === action)
                 return { ...(await shards.migrate()), path: root };
             if (RECORD === action) {
                 const written = await shards.record({
-                    id: asString(args['id']) ?? '',
-                    statement: asString(args['statement']) ?? '',
+                    id: need('id'),
+                    statement: need('statement'),
                     subject: asString(args['subject']),
                     why: asString(args['why']),
                     source: asString(args['source']),
@@ -157,7 +166,7 @@ export const INTENT_TOOLS = [
                 return { record: written, path: root };
             }
             if (BIND === action) {
-                const id = asString(args['id']) ?? '';
+                const id = need('id');
                 return { bound: await store.bind(id, args['binding']) };
             }
             if (LIST === action) {
@@ -223,38 +232,6 @@ async function withExistingFiles(deps, projectDir, entries) {
     return { entries: kept, missing };
 }
 const NO_SUBJECT_FIX = 'Nothing says what these are about, so an agent looking for them cannot find them: declare each again with surface.route (the page it is about) or surface.flow.';
-const MAX_REQUEST = 20_000;
-const MAX_STATEMENT = 500;
-const MAX_STATEMENTS = 100;
-const PROJECT_CONFIG = '.reticle.json';
-/** Credentials and personal data out, length capped: the same rules feedback reports follow. */
-function redactSecrets(text, max) {
-    return redactFeedbackText(text, max).text;
-}
-/**
- * Whether the request goes to the platform with the runs that verify it.
- *
- * A LINKED project shares it unless `.reticle.json` says `"shareRequests": false`: the platform
- * reads what each run was for, which is half of what a run means. An unlinked project has nowhere
- * to send it, and `"shareRequests": true` still shares from one that links later.
- */
-function sharesRequests(projectDir, reticleRoot) {
-    let setting;
-    try {
-        const config = JSON.parse(readFileSync(join(projectDir, PROJECT_CONFIG), 'utf8'));
-        setting = config?.shareRequests;
-    }
-    catch {
-        setting = undefined;
-    }
-    if (false === setting)
-        return false;
-    if (true === setting)
-        return true;
-    // Linked by `reticle connect` (cloud.json), or by a key in the environment, the way CI syncs.
-    return (existsSync(join(reticleRoot, ReticleDir.CLOUD_LINK_FILE)) ||
-        apiKeyFrom(process.env) !== undefined);
-}
 /**
  * Keep the user's request, and every statement in it and in the declared intents, classified and
  * attributed, for the runs that verify it. Secrets are redacted before anything is written.
@@ -262,29 +239,11 @@ function sharesRequests(projectDir, reticleRoot) {
  * Shared with the platform from a linked project unless `.reticle.json` says `"shareRequests": false`.
  */
 async function recordRequest(deps, root, request, declared) {
-    const text = redactSecrets(request, MAX_REQUEST);
     const agentStatements = declared.flatMap((d) => {
         const statement = d?.statement;
         return 'string' === typeof statement ? [statement] : [];
     });
-    const context = {
-        request: text,
-        statements: [
-            ...splitStatements(text).map((t) => ({ text: t, source: StatementSource.USER })),
-            ...agentStatements.map((t) => ({
-                text: redactSecrets(t, MAX_STATEMENT),
-                source: StatementSource.AGENT,
-            })),
-        ]
-            .slice(0, MAX_STATEMENTS)
-            .map((s) => ({
-            ...s,
-            text: s.text.slice(0, MAX_STATEMENT),
-            kind: classifyStatement(s.text),
-        })),
-        at: deps.now(),
-        shared: sharesRequests(dirname(root), root),
-    };
+    const context = promptContextFor(request, agentStatements, deps.now(), sharesRequests(dirname(root), root));
     const path = reticleDirPaths(root).request;
     await deps.fs.mkdir(dirname(path));
     await deps.fs.writeFile(path, `${JSON.stringify(context, null, 2)}\n`);

package/dist/memory/intent/record-request.d.ts

@@ -0,0 +1,27 @@
+import { type PromptContext } from '@reticlehq/core/artifacts';
+export declare const MAX_REQUEST = 20000;
+export declare const PROJECT_CONFIG = ".reticle.json";
+/** Credentials and personal data out, length capped: the same rules feedback reports follow. */
+export declare function redactSecrets(text: string, max: number): string;
+/** One setting from the project's `.reticle.json`, or undefined when it is absent or unreadable. */
+export declare function projectSetting(projectDir: string, key: string): unknown;
+/**
+ * The one switch for everything the agent hooks keep: prompts, tool calls, the model and the
+ * closing message. `RETICLE_PROMPT_CAPTURE=0` stops it on this machine.
+ */
+export declare function agentCaptureOff(env: NodeJS.ProcessEnv): boolean;
+/** The same switch for one project: `"promptCapture": false` in its `.reticle.json`. */
+export declare function agentCaptureOffIn(projectDir: string): boolean;
+/**
+ * Whether the request goes to the platform with the runs that verify it.
+ *
+ * A LINKED project shares it unless `.reticle.json` says `"shareRequests": false`: the platform
+ * reads what each run was for, which is half of what a run means. An unlinked project has nowhere
+ * to send it, and `"shareRequests": true` still shares from one that links later.
+ */
+export declare function sharesRequests(projectDir: string, reticleRoot: string): boolean;
+/**
+ * The prompt context for one request. `agentStatements` are the statements the agent declared
+ * beside it; the hook has none. Pure: the clock and the share decision arrive as values.
+ */
+export declare function promptContextFor(request: string, agentStatements: readonly string[], at: number, shared: boolean): PromptContext;

package/dist/memory/intent/record-request.js

@@ -0,0 +1,88 @@
+/**
+ * The user's request as Reticle keeps it: redacted, split into statements, classified, and marked
+ * shared or not. Two writers use it. `reticle_intent { declare, request }` records what the agent
+ * relays, and `reticle hook prompt` records what the user typed, before the agent sees it. One
+ * function, so the two writers cannot keep the request in two shapes.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { StatementSource, classifyStatement, splitStatements, } from '@reticlehq/core/artifacts';
+import { ReticleDir, ReticleEnv, apiKeyFrom, mainCheckoutTwin } from '@reticlehq/core';
+import { readTextOrUndefined } from '../project/fs/fs-port.js';
+import { redactFeedbackText } from '../../telemetry/feedback.js';
+export const MAX_REQUEST = 20_000;
+const MAX_STATEMENT = 500;
+const MAX_STATEMENTS = 100;
+export const PROJECT_CONFIG = '.reticle.json';
+const OFF_VALUES = new Set(['0', 'false', 'off', 'no']);
+/** Credentials and personal data out, length capped: the same rules feedback reports follow. */
+export function redactSecrets(text, max) {
+    return redactFeedbackText(text, max).text;
+}
+/** One setting from the project's `.reticle.json`, or undefined when it is absent or unreadable. */
+export function projectSetting(projectDir, key) {
+    try {
+        const config = JSON.parse(readFileSync(join(projectDir, PROJECT_CONFIG), 'utf8'));
+        return 'object' === typeof config && null !== config
+            ? config[key]
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The one switch for everything the agent hooks keep: prompts, tool calls, the model and the
+ * closing message. `RETICLE_PROMPT_CAPTURE=0` stops it on this machine.
+ */
+export function agentCaptureOff(env) {
+    return OFF_VALUES.has((env[ReticleEnv.PROMPT_CAPTURE] ?? '').toLowerCase());
+}
+/** The same switch for one project: `"promptCapture": false` in its `.reticle.json`. */
+export function agentCaptureOffIn(projectDir) {
+    return false === projectSetting(projectDir, 'promptCapture');
+}
+/**
+ * Whether the request goes to the platform with the runs that verify it.
+ *
+ * A LINKED project shares it unless `.reticle.json` says `"shareRequests": false`: the platform
+ * reads what each run was for, which is half of what a run means. An unlinked project has nowhere
+ * to send it, and `"shareRequests": true` still shares from one that links later.
+ */
+export function sharesRequests(projectDir, reticleRoot) {
+    const setting = projectSetting(projectDir, 'shareRequests');
+    if (false === setting)
+        return false;
+    if (true === setting)
+        return true;
+    // Linked by `reticle connect` (cloud.json), or by a key in the environment, the way CI syncs.
+    return (existsSync(join(reticleRoot, ReticleDir.CLOUD_LINK_FILE)) ||
+        // A git worktree of a linked project is linked: its `.reticle/` is often git-ignored.
+        existsSync(join(mainCheckoutTwin(reticleRoot, readTextOrUndefined) ?? reticleRoot, ReticleDir.CLOUD_LINK_FILE)) ||
+        apiKeyFrom(process.env) !== undefined);
+}
+/**
+ * The prompt context for one request. `agentStatements` are the statements the agent declared
+ * beside it; the hook has none. Pure: the clock and the share decision arrive as values.
+ */
+export function promptContextFor(request, agentStatements, at, shared) {
+    const text = redactSecrets(request, MAX_REQUEST);
+    return {
+        request: text,
+        statements: [
+            ...splitStatements(text).map((t) => ({ text: t, source: StatementSource.USER })),
+            ...agentStatements.map((t) => ({
+                text: redactSecrets(t, MAX_STATEMENT),
+                source: StatementSource.AGENT,
+            })),
+        ]
+            .slice(0, MAX_STATEMENTS)
+            .map((s) => ({
+            ...s,
+            text: s.text.slice(0, MAX_STATEMENT),
+            kind: classifyStatement(s.text),
+        })),
+        at,
+        shared,
+    };
+}

package/dist/memory/intent/settled-words.js

@@ -77,6 +77,9 @@ export async function applySettledWords(store, settled) {
         const decision = settled.find((s) => s.setAside === record.statement);
         if (decision === undefined)
             continue;
+        // The status the team settled on the kept words comes with them, in this same read: the next
+        // read of an unchanged memory is a 304, which would leave the record proposed.
+        const keptStatus = settled.find((s) => s.status !== undefined && s.kept === decision.kept)?.status;
         const next = await store.upsert(record.id, (existing) => 
         // The check bound to the words set aside proves nothing about the words kept.
         existing === undefined
@@ -89,7 +92,12 @@ export async function applySettledWords(store, settled) {
                     ...existing.surface,
                     files: decision.file === undefined ? [] : [decision.file],
                 },
-            }, { source: decidedBy(decision.by) });
+            }, {
+            source: decidedBy(decision.by),
+            ...(keptStatus !== undefined && RANK[keptStatus] > RANK[record.status]
+                ? { status: keptStatus }
+                : {}),
+        });
         if (next?.statement === decision.kept)
             changed += 1;
     }

package/dist/memory/journal/drive-flow.d.ts

@@ -29,6 +29,9 @@ export interface DriveProgram {
     steps: TapeStep[];
     startPath?: string;
     author?: FlowFile['author'];
+    /** Built from the steps' expects when no step declared an intent. Never a declared goal. */
+    intent?: string;
+    intentDerived?: true;
 }
 /**
  * What a session drove, saved as a replayable flow — without anybody asking for it.