@stigmer/runner 0.1.0-dev.20261017020314.g644422724c27

package/dist/__test-utils__/turn-input-fixture.js

@@ -0,0 +1,129 @@
+/**
+ * A whole `TurnInput` for tests that stand in for the runtime.
+ *
+ * The contract's input is the runtime's entire resolved record (`harness/
+ * types.ts`): the execution and session protos, the blueprint, the
+ * run's values, the workspace, the tool surface, the attachments, the model
+ * preferences, the standing context. A test that drives an adapter WITHOUT
+ * the runtime — the harness contract kit's `ExecutionDriver`, a unit test of
+ * one adapter step — needs a record that type-checks and is inert: empty
+ * protos, an empty tool surface, a workspace under the OS temp dir, a memory
+ * selection that answers nothing. Everything here is the neutral value;
+ * `overrides` deep-merges one level (a test states the fields it is about
+ * and nothing else), the way `testConfig()` does for `Config`.
+ *
+ * Nothing here is Cursor's or native's: the vision profile, the file-review
+ * identity and the state id source are the ADAPTER's capabilities, not
+ * input facts, so they do not appear.
+ */
+import { create } from "@bufbuild/protobuf";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { RunSchema, } from "@stigmer/apis/ai/stigmer/agentic/run/v1/api_pb";
+import { RunSpecSchema } from "@stigmer/apis/ai/stigmer/agentic/run/v1/spec_pb";
+import { ServiceTier, ThinkingMode } from "@stigmer/apis/ai/stigmer/agentic/run/v1/enum_pb";
+import { SessionSchema } from "@stigmer/apis/ai/stigmer/agentic/session/v1/api_pb";
+import { SessionSpecSchema } from "@stigmer/apis/ai/stigmer/agentic/session/v1/spec_pb";
+import { AgentSpecSchema } from "@stigmer/apis/ai/stigmer/agentic/agent/v1/spec_pb";
+import { ApiResourceMetadataSchema } from "@stigmer/apis/ai/stigmer/commons/apiresource/metadata_pb";
+import { ToolScope } from "../shared/tool-lists.js";
+import { NO_RUN_VALUES } from "../shared/run-values.js";
+import { mockWorkspaceBackend } from "./mock-workspace.js";
+/** The ids a fixture record carries when a test does not name its own. */
+export const TURN_INPUT_FIXTURE_IDS = {
+    executionId: "aex_fixture_0001",
+    sessionId: "ses_fixture_0001",
+    agentId: "agt_fixture_0001",
+    org: "fixture-org",
+};
+/**
+ * The neutral record, with `overrides` laid over it one level deep. The
+ * `session` and `blueprint.session` are the SAME object, as the runtime
+ * guarantees (`bindHarnessState` writes it).
+ */
+export function turnInputFixture(overrides = {}) {
+    const executionId = overrides.executionId ?? TURN_INPUT_FIXTURE_IDS.executionId;
+    const sessionId = overrides.sessionId ?? TURN_INPUT_FIXTURE_IDS.sessionId;
+    const session = overrides.session ??
+        create(SessionSchema, {
+            metadata: create(ApiResourceMetadataSchema, { id: sessionId, org: TURN_INPUT_FIXTURE_IDS.org, name: sessionId }),
+            spec: create(SessionSpecSchema, {}),
+        });
+    const execution = overrides.execution ??
+        create(RunSchema, {
+            metadata: create(ApiResourceMetadataSchema, { id: executionId, org: TURN_INPUT_FIXTURE_IDS.org, name: executionId }),
+            spec: create(RunSpecSchema, { target: { case: "sessionId", value: sessionId }, message: overrides.message ?? "" }),
+            status: overrides.persistedStatus,
+        });
+    const agent = {
+        id: TURN_INPUT_FIXTURE_IDS.agentId,
+        versionHash: "",
+        spec: create(AgentSpecSchema, { instructions: "You are the fixture agent." }),
+    };
+    const workspaceDir = overrides.workspaceDir ?? join(tmpdir(), "stigmer-runner-turn-input-fixture");
+    const blueprint = {
+        agent,
+        session,
+        sessionSpec: session.spec,
+        instructions: agent.spec.instructions,
+        pluginAgents: [],
+        subagents: [],
+        plugins: [],
+        mergedSkillRefs: [],
+        cloudRepos: [],
+        ...overrides.blueprint,
+    };
+    return {
+        executionId,
+        threadId: overrides.threadId ?? "",
+        turnSeq: overrides.turnSeq ?? 0,
+        sessionId,
+        approvalDecisions: overrides.approvalDecisions ?? new Map(),
+        approvalDenyMessages: overrides.approvalDenyMessages ?? new Map(),
+        approvalAsks: overrides.approvalAsks ?? new Map(),
+        readRunEvents: overrides.readRunEvents ?? (async () => []),
+        execution,
+        session,
+        blueprint,
+        values: overrides.values ?? NO_RUN_VALUES,
+        workspace: overrides.workspace ?? {
+            dirs: [workspaceDir],
+            primaryDir: workspaceDir,
+            gitWorkspace: false,
+            // Review on with nothing to capture into: the classic deny-gate, the
+            // posture the adapter-side kit's gating arms are written against.
+            captureSubstrate: false,
+            fileReview: true,
+            captureMode: false,
+            changeSetId: `${executionId}:${overrides.turnSeq ?? 0}`,
+            provision: { workspaceDirs: [workspaceDir], provisionResults: [], workspaceBackend: mockWorkspaceBackend() },
+        },
+        mcp: overrides.mcp ?? {
+            servers: [],
+            channelMessaging: [],
+            leases: { global: false, categories: new Set(), servers: new Set(), hooks: new Set() },
+            mcpDefault: { destructive: new Set(), unlisted: new Set(), leasedServers: new Set() },
+            listing: undefined,
+            platformServerSlugs: new Set(),
+            toolScope: ToolScope.unrestricted(),
+        },
+        skills: overrides.skills ?? { root: [], bySubAgent: new Map() },
+        hooks: overrides.hooks ?? { sources: [], serverNames: new Map() },
+        subagents: overrides.subagents ?? [],
+        attachments: overrides.attachments ?? { results: [], visionImages: [], visionNotViewable: [] },
+        appliedToolCallIds: overrides.appliedToolCallIds ?? new Set(),
+        model: overrides.model ?? { requested: "default", serviceTier: ServiceTier.STANDARD, thinkingMode: ThinkingMode.DISABLED },
+        structuredOutputSchema: overrides.structuredOutputSchema,
+        appendSystemPrompt: overrides.appendSystemPrompt ?? "",
+        standing: overrides.standing ?? {
+            contextBridge: undefined,
+            senderIdentity: undefined,
+            sessionContext: undefined,
+            declaredPreferences: undefined,
+            conversationCatchup: undefined,
+            selectRecalledMemories: async () => undefined,
+        },
+        artifactStorage: overrides.artifactStorage,
+    };
+}
+//# sourceMappingURL=turn-input-fixture.js.map

package/dist/__test-utils__/turn-input-fixture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-input-fixture.js","sourceRoot":"","sources":["../../src/__test-utils__/turn-input-fixture.ts"],"names":[],"mappings":"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"}

package/dist/activities/attach-session.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Warm-pool attach activities.
+ *
+ * Registered in the standard activity set (both runner and runner-manager
+ * copies) but functional only inside a pool member: they read the pool
+ * context registered by the pool boot path (see pool-member.ts) and fail
+ * fast everywhere else. The control plane schedules them on the member's
+ * control queue `sandbox:{memberId}`, which only a pool member ever polls.
+ *
+ * Activity contracts (invoked by the cloud ClaimPoolMemberWorkflow):
+ *
+ *   Name:   "ProbePoolMember"
+ *   Input:  none
+ *   Output: string (the member id — proof the member is booted and polling)
+ *
+ *   Name:   "AttachSession"
+ *   Input:  (sessionId: string)
+ *   Output: string (the session task queue now being polled)
+ *
+ * AttachSession is the claim hand-off: exchange the member's pool_sandbox
+ * credential for the session's sandbox token (the control plane authorizes
+ * against the claim record), push the session token to every credential sink
+ * via the manager, then start the session worker. From the returned ack
+ * onward the member serves `session:{sessionId}` like any provisioned
+ * sandbox. The control worker keeps polling its (now permanently idle)
+ * control queue — the claim deleted the pool row, so nothing dispatches
+ * there again, and the worker disappears with the next pod restart; tearing
+ * down the worker an activity is running on would deadlock the teardown.
+ */
+import type { Config } from "../config.js";
+export declare function createAttachSessionActivities(config: Config): {
+    ProbePoolMember: () => Promise<string>;
+    AttachSession: (sessionId: string) => Promise<string>;
+};

package/dist/activities/attach-session.js

@@ -0,0 +1,94 @@
+/**
+ * Warm-pool attach activities.
+ *
+ * Registered in the standard activity set (both runner and runner-manager
+ * copies) but functional only inside a pool member: they read the pool
+ * context registered by the pool boot path (see pool-member.ts) and fail
+ * fast everywhere else. The control plane schedules them on the member's
+ * control queue `sandbox:{memberId}`, which only a pool member ever polls.
+ *
+ * Activity contracts (invoked by the cloud ClaimPoolMemberWorkflow):
+ *
+ *   Name:   "ProbePoolMember"
+ *   Input:  none
+ *   Output: string (the member id — proof the member is booted and polling)
+ *
+ *   Name:   "AttachSession"
+ *   Input:  (sessionId: string)
+ *   Output: string (the session task queue now being polled)
+ *
+ * AttachSession is the claim hand-off: exchange the member's pool_sandbox
+ * credential for the session's sandbox token (the control plane authorizes
+ * against the claim record), push the session token to every credential sink
+ * via the manager, then start the session worker. From the returned ack
+ * onward the member serves `session:{sessionId}` like any provisioned
+ * sandbox. The control worker keeps polling its (now permanently idle)
+ * control queue — the claim deleted the pool row, so nothing dispatches
+ * there again, and the worker disappears with the next pod restart; tearing
+ * down the worker an activity is running on would deadlock the teardown.
+ */
+import { StigmerClient } from "../client/stigmer-client.js";
+import { activityStarted, activityFinished } from "../idle-watchdog.js";
+import { getPoolMemberContext } from "../pool-member.js";
+import { TimingRecorder, emitTimingLog } from "../shared/cold-start-timing.js";
+export function createAttachSessionActivities(config) {
+    const client = new StigmerClient({
+        endpoint: config.stigmerBackendEndpoint,
+        tokenRef: config.stigmerTokenRef,
+        runnerTokenRef: config.stigmerRunnerTokenRef,
+    });
+    return {
+        ProbePoolMember: async () => {
+            activityStarted();
+            try {
+                const pool = getPoolMemberContext();
+                if (!pool) {
+                    throw new Error("ProbePoolMember invoked outside a pool member (no pool context registered)");
+                }
+                return pool.memberId;
+            }
+            finally {
+                activityFinished();
+            }
+        },
+        AttachSession: async (sessionId) => {
+            activityStarted();
+            const timing = new TimingRecorder();
+            try {
+                const pool = getPoolMemberContext();
+                if (!pool) {
+                    throw new Error("AttachSession invoked outside a pool member (no pool context registered)");
+                }
+                if (!sessionId) {
+                    throw new Error("AttachSession requires a session id");
+                }
+                const scoped = await client.getRunnerScopedToken({ poolClaimSessionId: sessionId }, pool.poolToken);
+                timing.mark("exchange_token");
+                if (!scoped) {
+                    // Unlike the desktop exchange, there is no credential to fall back
+                    // to: a pool token cannot serve session work, so an empty mint is a
+                    // hard failure and the control plane discards this member.
+                    throw new Error("control plane minted no session token for the pool claim " +
+                        `(member=${pool.memberId}, session=${sessionId})`);
+                }
+                pool.manager.updateToken(scoped.token);
+                timing.mark("token_applied");
+                await pool.manager.addSession(sessionId);
+                timing.mark("session_worker_added");
+                const taskQueue = `session:${sessionId}`;
+                emitTimingLog("pool_attach", {
+                    pool_member_id: pool.memberId,
+                    session_id: sessionId,
+                    task_queue: taskQueue,
+                }, timing);
+                console.log(`[attach-session] Pool member ${pool.memberId} attached to session ` +
+                    `${sessionId} (queue=${taskQueue})`);
+                return taskQueue;
+            }
+            finally {
+                activityFinished();
+            }
+        },
+    };
+}
+//# sourceMappingURL=attach-session.js.map

package/dist/activities/attach-session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attach-session.js","sourceRoot":"","sources":["../../src/activities/attach-session.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACxE,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/E,MAAM,UAAU,6BAA6B,CAAC,MAAc;IAC1D,MAAM,MAAM,GAAG,IAAI,aAAa,CAAC;QAC/B,QAAQ,EAAE,MAAM,CAAC,sBAAsB;QACvC,QAAQ,EAAE,MAAM,CAAC,eAAe;QAChC,cAAc,EAAE,MAAM,CAAC,qBAAqB;KAC7C,CAAC,CAAC;IAEH,OAAO;QACL,eAAe,EAAE,KAAK,IAAqB,EAAE;YAC3C,eAAe,EAAE,CAAC;YAClB,IAAI,CAAC;gBACH,MAAM,IAAI,GAAG,oBAAoB,EAAE,CAAC;gBACpC,IAAI,CAAC,IAAI,EAAE,CAAC;oBACV,MAAM,IAAI,KAAK,CACb,4EAA4E,CAC7E,CAAC;gBACJ,CAAC;gBACD,OAAO,IAAI,CAAC,QAAQ,CAAC;YACvB,CAAC;oBAAS,CAAC;gBACT,gBAAgB,EAAE,CAAC;YACrB,CAAC;QACH,CAAC;QAED,aAAa,EAAE,KAAK,EAAE,SAAiB,EAAmB,EAAE;YAC1D,eAAe,EAAE,CAAC;YAClB,MAAM,MAAM,GAAG,IAAI,cAAc,EAAE,CAAC;YACpC,IAAI,CAAC;gBACH,MAAM,IAAI,GAAG,oBAAoB,EAAE,CAAC;gBACpC,IAAI,CAAC,IAAI,EAAE,CAAC;oBACV,MAAM,IAAI,KAAK,CACb,0EAA0E,CAC3E,CAAC;gBACJ,CAAC;gBACD,IAAI,CAAC,SAAS,EAAE,CAAC;oBACf,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;gBACzD,CAAC;gBAED,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,oBAAoB,CAC9C,EAAE,kBAAkB,EAAE,SAAS,EAAE,EACjC,IAAI,CAAC,SAAS,CACf,CAAC;gBACF,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;gBAC9B,IAAI,CAAC,MAAM,EAAE,CAAC;oBACZ,mEAAmE;oBACnE,oEAAoE;oBACpE,2DAA2D;oBAC3D,MAAM,IAAI,KAAK,CACb,2DAA2D;wBACzD,WAAW,IAAI,CAAC,QAAQ,aAAa,SAAS,GAAG,CACpD,CAAC;gBACJ,CAAC;gBAED,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBACvC,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;gBAE7B,MAAM,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;gBACzC,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;gBAEpC,MAAM,SAAS,GAAG,WAAW,SAAS,EAAE,CAAC;gBACzC,aAAa,CAAC,aAAa,EAAE;oBAC3B,cAAc,EAAE,IAAI,CAAC,QAAQ;oBAC7B,UAAU,EAAE,SAAS;oBACrB,UAAU,EAAE,SAAS;iBACtB,EAAE,MAAM,CAAC,CAAC;gBACX,OAAO,CAAC,GAAG,CACT,gCAAgC,IAAI,CAAC,QAAQ,uBAAuB;oBAClE,GAAG,SAAS,WAAW,SAAS,GAAG,CACtC,CAAC;gBACF,OAAO,SAAS,CAAC;YACnB,CAAC;oBAAS,CAAC;gBACT,gBAAgB,EAAE,CAAC;YACrB,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/activities/ensure-thread.d.ts

@@ -0,0 +1,24 @@
+/**
+ * EnsureThread Temporal activity — resolves a LangGraph thread ID for an
+ * agent execution.
+ *
+ * Called by the Java/Go InvokeAgentExecutionWorkflow as Step 1 of the
+ * native (deep-agent) harness flow, before ExecuteDeepAgent. The returned
+ * thread ID keys the LangGraph checkpointer for conversation continuity.
+ *
+ * Thread ID conventions (load-bearing for proxy authorization):
+ *   - Session-based:  "thread-{sessionId}"   — deterministic, no DB call
+ *   - Ephemeral:      "ephemeral-{agentId}-{8hex}" — single-use
+ *
+ * The "thread-{sessionId}" prefix is parsed by ProxyAuthorizationService
+ * (stigmer-cloud) to extract the session ID for checkpoint access control.
+ * Changing the format requires a coordinated update.
+ *
+ * Activity contract:
+ *   Name:   "EnsureThread"
+ *   Input:  (sessionId: string, agentId: string)
+ *   Output: string (thread ID)
+ */
+export declare function createEnsureThreadActivities(): {
+    EnsureThread: (sessionId: string, agentId: string) => Promise<string>;
+};

package/dist/activities/ensure-thread.js

@@ -0,0 +1,44 @@
+/**
+ * EnsureThread Temporal activity — resolves a LangGraph thread ID for an
+ * agent execution.
+ *
+ * Called by the Java/Go InvokeAgentExecutionWorkflow as Step 1 of the
+ * native (deep-agent) harness flow, before ExecuteDeepAgent. The returned
+ * thread ID keys the LangGraph checkpointer for conversation continuity.
+ *
+ * Thread ID conventions (load-bearing for proxy authorization):
+ *   - Session-based:  "thread-{sessionId}"   — deterministic, no DB call
+ *   - Ephemeral:      "ephemeral-{agentId}-{8hex}" — single-use
+ *
+ * The "thread-{sessionId}" prefix is parsed by ProxyAuthorizationService
+ * (stigmer-cloud) to extract the session ID for checkpoint access control.
+ * Changing the format requires a coordinated update.
+ *
+ * Activity contract:
+ *   Name:   "EnsureThread"
+ *   Input:  (sessionId: string, agentId: string)
+ *   Output: string (thread ID)
+ */
+import { randomUUID } from "node:crypto";
+import { activityStarted, activityFinished } from "../idle-watchdog.js";
+export function createEnsureThreadActivities() {
+    return {
+        EnsureThread: async (sessionId, agentId) => {
+            activityStarted();
+            try {
+                if (sessionId) {
+                    const threadId = `thread-${sessionId}`;
+                    console.log(`[EnsureThread] Session-based thread: ${threadId}`);
+                    return threadId;
+                }
+                const threadId = `ephemeral-${agentId}-${randomUUID().replace(/-/g, "").slice(0, 8)}`;
+                console.log(`[EnsureThread] Ephemeral thread: ${threadId}`);
+                return threadId;
+            }
+            finally {
+                activityFinished();
+            }
+        },
+    };
+}
+//# sourceMappingURL=ensure-thread.js.map

package/dist/activities/ensure-thread.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensure-thread.js","sourceRoot":"","sources":["../../src/activities/ensure-thread.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAExE,MAAM,UAAU,4BAA4B;IAC1C,OAAO;QACL,YAAY,EAAE,KAAK,EAAE,SAAiB,EAAE,OAAe,EAAmB,EAAE;YAC1E,eAAe,EAAE,CAAC;YAClB,IAAI,CAAC;gBACH,IAAI,SAAS,EAAE,CAAC;oBACd,MAAM,QAAQ,GAAG,UAAU,SAAS,EAAE,CAAC;oBACvC,OAAO,CAAC,GAAG,CAAC,wCAAwC,QAAQ,EAAE,CAAC,CAAC;oBAChE,OAAO,QAAQ,CAAC;gBAClB,CAAC;gBAED,MAAM,QAAQ,GAAG,aAAa,OAAO,IAAI,UAAU,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;gBACtF,OAAO,CAAC,GAAG,CAAC,oCAAoC,QAAQ,EAAE,CAAC,CAAC;gBAC5D,OAAO,QAAQ,CAAC;YAClB,CAAC;oBAAS,CAAC;gBACT,gBAAgB,EAAE,CAAC;YACrB,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/activities/execute-cursor/__test-utils__/contract-subject.d.ts

@@ -0,0 +1,107 @@
+/**
+ * The Cursor harness as a `HarnessContractSubject` — the REAL `createCursorAdapter()`
+ * driven through the harness contract kit, with the kit's engine-neutral
+ * scenario vocabulary translated onto the scripted `@cursor/sdk` double (#1048).
+ *
+ * The sibling of `gateway-substrate.ts` (the Cursor side of the approval
+ * contract kit): the kit owns the invariants and the runtime stand-in, this
+ * module owns the ENGINE — what the next turn of a session's agent will do —
+ * and reports what the double observed. The adapter under test is the
+ * production one, untouched; it imports no `@temporalio/*` (the fence test
+ * pins that), which is what lets the kit run it outside any activity
+ * context.
+ *
+ * ── The engine is per session ───────────────────────────────────────────────
+ * One scripted agent per session, minted when the kit first arranges a turn
+ * for it and handed out by the double's `Agent.create` for THAT session (keyed
+ * by the SDK's `platform.workspaceRef`, computed the way the adapter computes
+ * it), then parked by the real session cache across turns exactly as in a live
+ * worker. Arranging a turn REPLACES the agent's next script, so a turn the
+ * adapter interrupts before its `send()` leaves no stale script for the
+ * session's next turn. Every session also gets the workspace directory the
+ * runtime's provisioner would give it (`<workspaceRootDir>/sessions/<id>`), so
+ * both halves of the kit gate in the same directory shape; the hook's
+ * active-turn pointer is per workspace, so concurrent sessions cannot repoint
+ * each other's hook.
+ *
+ * ── The translation, one rule per word ──────────────────────────────────────
+ *  - `say(text)`      → an `assistant` event. A first send opens with the
+ *                       `system/init` event; a resumed send does not (the
+ *                       `deny-and-retry` turn-2 script is the precedent).
+ *  - `propose(id, a)` → the STREAM tool call (`edit` / `shell` / `delete`, the
+ *                       kits' shared translation in `cursor-hook-harness.ts`),
+ *                       an `effect` that runs the REAL preToolUse hook the
+ *                       adapter installed against the session's workspace,
+ *                       and the call's completion event. `executionCount(id)`
+ *                       is the hook's `allow` answers for `id` — the SDK
+ *                       executes a tool iff the hook allows it, so this is the
+ *                       safety-critical observable. WHETHER the call is
+ *                       emitted is decided from the kit's view and this
+ *                       subject's own memory, as the model and the SDK would
+ *                       decide it (see {@link CursorContractSubject.proposeSteps}).
+ *  - `read(id, path)` → the `read` tool call, the REAL hook (which allows it —
+ *                       a read is never gated) and the completion; counted as
+ *                       run. The discrete event the adapter's loop flushes a
+ *                       persist on.
+ *  - `usage(delta)`   → a `turn-ended` delta; the adapter prices it.
+ *  - `hang`           → an `effect` parked on the run's own `cancelled`
+ *                       status, which the adapter's stop-signal listener
+ *                       (`turn-stream.ts` `cancelOnStop`) produces. Never a
+ *                       timer. Resolves `whenHanging`.
+ *  - `fail(msg, s)`   → `engine`: the run ends `{ status: "error" }` and
+ *                       `run.wait()` carries the message; `internal`: an
+ *                       `effect` throws mid-stream (the adapter's catch
+ *                       classifies it). `actionable` is refused as a test bug:
+ *                       only the unattributed-hook-block path produces that
+ *                       surface, and the kit's invariants do not ask for it.
+ *  - `cancelled`      → an `effect` calling `run.cancel()` from the SDK side
+ *                       (the `run-cancelled` golden's shape).
+ * Every script that does not end in `fail`, `cancelled` or `hang` closes with
+ * `finished({ result: <last say> })` so `run.wait()` has an answer.
+ *
+ * ── Two modelling decisions (#1070) ─────────────────────────────────────────
+ * A `propose` for an id this subject has already seen the hook ALLOW emits
+ * nothing: the real SDK does not re-run a completed tool on resume — the parked
+ * agent's conversation already holds the tool's result. A `propose` whose id
+ * carries a SKIP or REJECT decision emits nothing either: the resume prompt
+ * tells the model the user declined the action and an obedient model moves
+ * on. Both are what "the engine re-reaches the same call" and "the turn
+ * continues" MEAN for a deny-and-retry harness; neither hides anything from
+ * the safety observable, because a fresh identical command from a
+ * disobedient model IS a new gated act and Cursor re-gates it — the subject
+ * file proves that with {@link CursorContractSubject.forceReissue}.
+ *
+ * The completion event a `propose` emits is scripted from the answer the hook
+ * is EXPECTED to give (deny for an undecided proposal, allow for an approved
+ * re-issue); the hook's actual answer is recorded at effect time and any
+ * disagreement is kept in {@link CursorContractSubject.hookDisagreements} for
+ * the subject file to assert empty — a hook that allows an undecided action
+ * would show up there AND in `executionCount`, never be papered over.
+ */
+import type { HarnessAdapter } from "../../../harness/types.js";
+import type { HarnessContractSubject } from "../../../__test-utils__/harness-contract/types.js";
+import type { HermeticEnvironment } from "../../../__test-utils__/hermetic-activity.js";
+import { ScriptedCursorAgent } from "./scripted-agent.js";
+import { ScriptedCursorSdk } from "./scripted-sdk.js";
+export interface CursorContractSubject extends HarnessContractSubject {
+    readonly adapter: HarnessAdapter;
+    /** The SDK double the adapter is talking to, for the subject file's own observations. */
+    readonly sdk: ScriptedCursorSdk;
+    /** The scripted agent minted for a session, once the kit has arranged a turn for it. */
+    agentFor(sessionId: string): ScriptedCursorAgent | undefined;
+    /**
+     * Make the NEXT `propose` of `toolCallId` emit its call whatever the
+     * decision or the memory says — the disobedient model, for the observation
+     * the kit's vocabulary cannot express.
+     */
+    forceReissue(toolCallId: string): void;
+    /** Every proposal at which the hook answered other than the script expected; the subject file asserts it stays empty. */
+    readonly hookDisagreements: readonly string[];
+}
+/**
+ * Build the subject over one hermetic environment (the temp `HOME` the gate's
+ * per-session HITL artifacts land under, the temp workspace root). The
+ * environment is the caller's to create before and dispose after; the SDK
+ * double is bound for the module here, so a file holds one subject.
+ */
+export declare function createCursorContractSubject(env: HermeticEnvironment): CursorContractSubject;