@stigmer/server 3.15.3-dev.20260914121148 → 3.16.0

package/src/temporal/agentexecution/workflows/invoke-agent-execution.ts

@@ -157,28 +157,77 @@ const approvalGateResolvedSignal = defineSignal(SIGNAL_APPROVAL_GATE_RESOLVED);
 
 // ─── Activity proxies (options are contract; see the census table) ──────
 
+/**
+ * The typed input of ExecuteDeepAgent and ExecuteCursor — the runner's
+ * ExecuteActivityInput (shared/activity-input.ts), snake_case keys, a
+ * cross-component wire contract. `execution_context_token` is the run
+ * credential the workflow input carries (workflow-input.ts), handed on
+ * so the activity can present it on the run's own RPCs; omitted when the
+ * dispatch carried none (the omitempty convention). Adding the key needed
+ * no patch marker: an in-flight history's input has no token, so the
+ * commands its replay generates are byte-for-byte what they were.
+ */
+interface ExecuteActivityInput {
+  readonly execution_id: string;
+  readonly thread_id: string;
+  readonly invoker_identity_account_id: string;
+  readonly turn_seq: number;
+  readonly execution_context_token?: string;
+}
+
+/**
+ * The typed input of GenerateSessionSubject — the runner's
+ * GenerateSessionSubjectInput (activities/generate-session-subject.ts),
+ * snake_case keys. Sent ONLY when the dispatch carries a run credential;
+ * otherwise the activity is called with the positional execution id it has
+ * always received, byte for byte, because a server whose dispatches carry
+ * no credential (the cloud's: its runner credential is provisioned, not
+ * dispatched) talks to desktop runners in the field that predate the object
+ * shape, and a session title is not worth breaking for them. A runner that
+ * knows the object accepts both.
+ */
+interface GenerateSessionSubjectInput {
+  readonly execution_id: string;
+  readonly execution_context_token: string;
+}
+
 interface RunnerActivities {
   [ENSURE_THREAD_ACTIVITY_NAME]: (
     sessionId: string,
     agentId: string,
   ) => Promise<string>;
-  [EXECUTE_DEEP_AGENT_ACTIVITY_NAME]: (input: {
-    execution_id: string;
-    thread_id: string;
-    invoker_identity_account_id: string;
-    turn_seq: number;
-  }) => Promise<RunnerActivityResult | null>;
-  [EXECUTE_CURSOR_ACTIVITY_NAME]: (input: {
-    execution_id: string;
-    thread_id: string;
-    invoker_identity_account_id: string;
-    turn_seq: number;
-  }) => Promise<RunnerActivityResult | null>;
+  [EXECUTE_DEEP_AGENT_ACTIVITY_NAME]: (
+    input: ExecuteActivityInput,
+  ) => Promise<RunnerActivityResult | null>;
+  [EXECUTE_CURSOR_ACTIVITY_NAME]: (
+    input: ExecuteActivityInput,
+  ) => Promise<RunnerActivityResult | null>;
   [GENERATE_SESSION_SUBJECT_ACTIVITY_NAME]: (
-    executionId: string,
+    input: GenerateSessionSubjectInput | string,
   ) => Promise<void>;
 }
 
+/**
+ * The ONE builder of an Execute* input for both harness flows and both
+ * invocations (first turn and every HITL re-invocation): the run's
+ * coordinates from the workflow input, the harness thread and the turn
+ * from the caller.
+ */
+function executeActivityInput(
+  input: InvokeAgentExecutionWorkflowInput,
+  threadId: string,
+  turnSeq: number,
+): ExecuteActivityInput {
+  const runCredential = input.execution_context_token ?? "";
+  return {
+    execution_id: input.execution_id,
+    thread_id: threadId,
+    invoker_identity_account_id: input.invoker_identity_account_id ?? "",
+    turn_seq: turnSeq,
+    ...(runCredential !== "" ? { execution_context_token: runCredential } : {}),
+  };
+}
+
 function newEnsureThreadProxy(taskQueue: string) {
   return proxyActivities<Pick<RunnerActivities, typeof ENSURE_THREAD_ACTIVITY_NAME>>({
     taskQueue,
@@ -516,7 +565,6 @@ async function executeDeepAgentFlow(
 ): Promise<RunnerActivityResult> {
   const executionId = input.execution_id;
   const sessionId = input.session_id;
-  const invoker = input.invoker_identity_account_id ?? "";
 
   log.info("Step 1: Ensuring thread", { sessionId, agentId: input.agent_id });
   const ensureThread = newEnsureThreadProxy(activityTaskQueue);
@@ -531,7 +579,7 @@ async function executeDeepAgentFlow(
   }
   log.info("Thread ensured", { threadId });
 
-  fireGenerateSessionSubject(activityTaskQueue, executionId);
+  fireGenerateSessionSubject(activityTaskQueue, input);
 
   log.info("Step 2: Executing deep agent", { executionId, threadId });
   const agentProxy = newExecuteAgentProxy(activityTaskQueue);
@@ -547,20 +595,14 @@ async function executeDeepAgentFlow(
         signals,
         parentWorkflowId: input.parent_workflow_id ?? "",
         firstInvoke: () =>
-          agentProxy[EXECUTE_DEEP_AGENT_ACTIVITY_NAME]({
-            execution_id: executionId,
-            thread_id: threadId,
-            invoker_identity_account_id: invoker,
-            turn_seq: 0,
-          }),
+          agentProxy[EXECUTE_DEEP_AGENT_ACTIVITY_NAME](
+            executeActivityInput(input, threadId, 0),
+          ),
         // The LangGraph thread id is stable — re-invocations reuse it.
         reinvoke: (turnSeq) =>
-          agentProxy[EXECUTE_DEEP_AGENT_ACTIVITY_NAME]({
-            execution_id: executionId,
-            thread_id: threadId,
-            invoker_identity_account_id: invoker,
-            turn_seq: turnSeq,
-          }),
+          agentProxy[EXECUTE_DEEP_AGENT_ACTIVITY_NAME](
+            executeActivityInput(input, threadId, turnSeq),
+          ),
         nullResultMessage: "activity returned null status - this should never happen",
         nullResultAfterApprovalMessage:
           "activity returned null status after approval - this should never happen",
@@ -584,9 +626,8 @@ async function executeCursorFlow(
 ): Promise<RunnerActivityResult> {
   const executionId = input.execution_id;
   const sessionId = input.session_id;
-  const invoker = input.invoker_identity_account_id ?? "";
 
-  fireGenerateSessionSubject(activityTaskQueue, executionId);
+  fireGenerateSessionSubject(activityTaskQueue, input);
 
   log.info("Executing Cursor agent", { executionId, sessionId });
   const agentProxy = newExecuteAgentProxy(activityTaskQueue);
@@ -612,12 +653,9 @@ async function executeCursorFlow(
             );
             harnessStateId = "";
           }
-          return agentProxy[EXECUTE_CURSOR_ACTIVITY_NAME]({
-            execution_id: executionId,
-            thread_id: harnessStateId,
-            invoker_identity_account_id: invoker,
-            turn_seq: 0,
-          });
+          return agentProxy[EXECUTE_CURSOR_ACTIVITY_NAME](
+            executeActivityInput(input, harnessStateId, 0),
+          );
         },
         reinvoke: async (turnSeq) => {
           let harnessStateId: string;
@@ -634,12 +672,9 @@ async function executeCursorFlow(
             cycle: turnSeq,
             harnessStateId,
           });
-          return agentProxy[EXECUTE_CURSOR_ACTIVITY_NAME]({
-            execution_id: executionId,
-            thread_id: harnessStateId,
-            invoker_identity_account_id: invoker,
-            turn_seq: turnSeq,
-          });
+          return agentProxy[EXECUTE_CURSOR_ACTIVITY_NAME](
+            executeActivityInput(input, harnessStateId, turnSeq),
+          );
         },
         nullResultMessage:
           "cursor activity returned null status - this should never happen",
@@ -649,15 +684,26 @@ async function executeCursorFlow(
   });
 }
 
-/** GenerateSessionSubject: fire-and-forget, non-blocking (issue #665). */
+/**
+ * GenerateSessionSubject: fire-and-forget, non-blocking (issue #665). The
+ * argument shape follows the run credential's presence — see
+ * GenerateSessionSubjectInput for why the credential-less dispatch keeps
+ * the positional string.
+ */
 function fireGenerateSessionSubject(
   activityTaskQueue: string,
-  executionId: string,
+  input: InvokeAgentExecutionWorkflowInput,
 ): void {
+  const executionId = input.execution_id;
+  const runCredential = input.execution_context_token ?? "";
+  const argument: GenerateSessionSubjectInput | string =
+    runCredential !== ""
+      ? { execution_id: executionId, execution_context_token: runCredential }
+      : executionId;
   const subjectProxy = newSubjectProxy(activityTaskQueue);
   void (async () => {
     try {
-      await subjectProxy[GENERATE_SESSION_SUBJECT_ACTIVITY_NAME](executionId);
+      await subjectProxy[GENERATE_SESSION_SUBJECT_ACTIVITY_NAME](argument);
     } catch (error) {
       log.warn("Session subject generation failed (non-critical)", {
         executionId,

package/src/temporal/schedule/__tests__/run-starter.test.ts

@@ -26,6 +26,7 @@ import { Harness } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
 import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
 
 import { createLogger } from "../../../boot/logger.js";
+import { ScheduleFireCallerRefusedError } from "../../../extensions/schedule-fire-caller.js";
 import { SqliteStore } from "../../../store/sqlite/store.js";
 import { ScheduleTemporalConfig } from "../config.js";
 import {
@@ -37,7 +38,11 @@ import {
   scheduledExecutionName,
 } from "../run-starter.js";
 
-const silentLogger = createLogger({ level: "error", pretty: false, write: () => {} });
+const silentLogger = createLogger({
+  level: "error",
+  pretty: false,
+  write: () => {},
+});
 
 const NOMINAL = new Date("2026-08-25T09:30:00Z");
 
@@ -49,13 +54,15 @@ describe("scheduledExecutionName — THE idempotency key (byte-pinned)", () => {
   });
 
   it("truncates the nominal time to whole seconds", () => {
-    expect(scheduledExecutionName("sch_x", new Date("2026-08-25T09:30:00.999Z"))).toBe(
-      "sch-x-20260825t093000z",
-    );
+    expect(
+      scheduledExecutionName("sch_x", new Date("2026-08-25T09:30:00.999Z")),
+    ).toBe("sch-x-20260825t093000z");
   });
 
   it("every character is slug-shaped (the name IS the execution's slug)", () => {
-    expect(scheduledExecutionName("sch_01ABC", NOMINAL)).toMatch(/^[a-z0-9-]+$/);
+    expect(scheduledExecutionName("sch_01ABC", NOMINAL)).toMatch(
+      /^[a-z0-9-]+$/,
+    );
   });
 });
 
@@ -71,7 +78,11 @@ function scheduleWith(overrides?: {
   slug?: string;
 }): Schedule {
   return create(ScheduleSchema, {
-    metadata: { id: "sch_01test", org: "acme", slug: overrides?.slug ?? "daily" },
+    metadata: {
+      id: "sch_01test",
+      org: "acme",
+      slug: overrides?.slug ?? "daily",
+    },
     spec: {
       cron: "0 9 * * *",
       timeZone: overrides?.timeZone ?? "Asia/Kolkata",
@@ -109,16 +120,18 @@ describe("composeMessage — the fire-context line (byte contract)", () => {
   });
 
   it("an unloadable zone degrades to UTC (a slightly wrong-timezone reminder beats a dead fire)", () => {
-    expect(composeMessage(scheduleWith({ timeZone: "Mars/Olympus" }), NOMINAL)).toBe(
+    expect(
+      composeMessage(scheduleWith({ timeZone: "Mars/Olympus" }), NOMINAL),
+    ).toBe(
       "Do the morning rounds\n\n(Scheduled fire time: Tuesday, 2026-08-25 09:30 (UTC))",
     );
   });
 
   it("uses h23 hours (Go's 15 layout: 00-23, never 24)", () => {
     const midnight = new Date("2026-08-25T00:05:00Z");
-    expect(composeMessage(scheduleWith({ timeZone: "UTC" }), midnight)).toContain(
-      "Tuesday, 2026-08-25 00:05 (UTC)",
-    );
+    expect(
+      composeMessage(scheduleWith({ timeZone: "UTC" }), midnight),
+    ).toContain("Tuesday, 2026-08-25 00:05 (UTC)");
   });
 });
 
@@ -176,7 +189,9 @@ describe("RunStarter.startRun — against a real store", () => {
     rmSync(dir, { recursive: true, force: true });
   });
 
-  function starter(create_: (execution: AgentExecution) => Promise<AgentExecution>) {
+  function starter(
+    create_: (execution: AgentExecution) => Promise<AgentExecution>,
+  ) {
     return new RunStarter({
       store,
       config,
@@ -208,14 +223,20 @@ describe("RunStarter.startRun — against a real store", () => {
     expect(seen?.metadata?.labels[SCHEDULE_ID_LABEL_KEY]).toBe("sch_01test");
     expect(seen?.spec?.agentId).toBe("agt_01helper");
     expect(seen?.spec?.message).toContain("(Scheduled fire time: ");
-    expect(seen?.spec?.sessionSpec?.subject).toBe(`${SESSION_SUBJECT_PREFIX}daily`);
-    expect(seen?.spec?.executionConfig?.approvalMode).toBe(ApprovalMode.UNATTENDED);
+    expect(seen?.spec?.sessionSpec?.subject).toBe(
+      `${SESSION_SUBJECT_PREFIX}daily`,
+    );
+    expect(seen?.spec?.executionConfig?.approvalMode).toBe(
+      ApprovalMode.UNATTENDED,
+    );
     // Platform profile applies when the owner set nothing.
     expect(seen?.spec?.executionConfig?.maxToolRounds).toBe(20);
     expect(seen?.spec?.executionConfig?.maxCostUsd).toBe(1.0);
     // Unset tier/model stay unset (never stamped).
     expect(seen?.spec?.executionConfig?.modelName).toBe("");
-    expect(seen?.spec?.executionConfig?.serviceTier).toBe(ServiceTier.UNSPECIFIED);
+    expect(seen?.spec?.executionConfig?.serviceTier).toBe(
+      ServiceTier.UNSPECIFIED,
+    );
 
     // Success stamped last_execution_id on the row.
     const row = await store.getResource(
@@ -333,11 +354,41 @@ describe("RunStarter.startRun — against a real store", () => {
         },
         logger: silentLogger,
       });
-      await expect(runStarter.startRun(scheduleWith(), NOMINAL)).rejects.toThrow(
+      await expect(
+        runStarter.startRun(scheduleWith(), NOMINAL),
+      ).rejects.toThrow(
         /mint schedule fire caller for sch_01test: account provisioning unavailable/,
       );
     });
 
+    it("answers `refused` when the mint's failure is the seam's deterministic refusal — the streak counts it, no retry", async () => {
+      let created = 0;
+      const runStarter = new RunStarter({
+        store,
+        config,
+        executions: {
+          create: async () => {
+            created += 1;
+            throw new Error("create must not run when the mint refused");
+          },
+        },
+        fireCallerMint: {
+          mintFireCaller: async () => {
+            throw new ScheduleFireCallerRefusedError(
+              "schedule sch_01test was created by nobody this server recognizes as a person",
+            );
+          },
+        },
+        logger: silentLogger,
+      });
+      expect(await runStarter.startRun(scheduleWith(), NOMINAL)).toEqual({
+        kind: "refused",
+        reason:
+          "schedule sch_01test was created by nobody this server recognizes as a person",
+      });
+      expect(created).toBe(0);
+    });
+
     it("never mints on the idempotent path (the winner needs no credential)", async () => {
       await store.saveResource(
         ApiResourceKind.agent_execution,
@@ -372,7 +423,10 @@ describe("RunStarter.startRun — against a real store", () => {
         executionId: "aex_01winner",
         alreadyExisted: true,
       });
-      await store.deleteResource(ApiResourceKind.agent_execution, "aex_01winner");
+      await store.deleteResource(
+        ApiResourceKind.agent_execution,
+        "aex_01winner",
+      );
     });
   });
 
@@ -410,13 +464,19 @@ describe("RunStarter.startRun — against a real store", () => {
     Code.NotFound,
     Code.InvalidArgument,
     Code.ResourceExhausted,
-  ])("maps the launch-gate code %s to a refused outcome (the streak counts it)", async (code) => {
-    const runStarter = starter(async () => {
-      throw new ConnectError("gate refused this run", code);
-    });
-    const outcome = await runStarter.startRun(scheduleWith(), NOMINAL);
-    expect(outcome).toEqual({ kind: "refused", reason: "gate refused this run" });
-  });
+  ])(
+    "maps the launch-gate code %s to a refused outcome (the streak counts it)",
+    async (code) => {
+      const runStarter = starter(async () => {
+        throw new ConnectError("gate refused this run", code);
+      });
+      const outcome = await runStarter.startRun(scheduleWith(), NOMINAL);
+      expect(outcome).toEqual({
+        kind: "refused",
+        reason: "gate refused this run",
+      });
+    },
+  );
 
   it("rethrows infrastructure codes so the activity retries", async () => {
     const runStarter = starter(async () => {
@@ -463,7 +523,9 @@ describe("RunStarter.startRun — against a real store", () => {
     let seen: AgentExecution | undefined;
     const runStarter = starter(async (execution) => {
       seen = execution;
-      return create(AgentExecutionSchema, { metadata: { id: "aex_01x", org: "acme" } });
+      return create(AgentExecutionSchema, {
+        metadata: { id: "aex_01x", org: "acme" },
+      });
     });
     await runStarter.startRun(
       scheduleWith({

package/src/temporal/schedule/run-starter.ts

@@ -48,6 +48,7 @@ import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/ap
 import type { Logger } from "../../boot/logger.js";
 import type { CallerIdentity } from "../../extensions/identity.js";
 import type { ScheduleFireCallerMint } from "../../extensions/schedule-fire-caller.js";
+import { ScheduleFireCallerRefusedError } from "../../extensions/schedule-fire-caller.js";
 import { findResourceBySlug } from "../../pipeline/steps/helpers.js";
 import { ResourceNotFoundError } from "../../store/interface.js";
 import type { Store } from "../../store/interface.js";
@@ -152,7 +153,9 @@ function fireContextLine(
   let zone = requestedZone;
   let parts: Intl.DateTimeFormatPart[];
   try {
-    parts = fireContextFormatter(zone === "" ? "UTC" : zone).formatToParts(nominal);
+    parts = fireContextFormatter(zone === "" ? "UTC" : zone).formatToParts(
+      nominal,
+    );
     if (zone === "") {
       zone = "UTC";
     }
@@ -209,7 +212,7 @@ export interface RunStarterDeps {
   readonly store: Store;
   readonly config: ScheduleTemporalConfig;
   readonly executions: ScheduleExecutionCreator;
-  /** The composed fire-caller mint, or undefined (the OSS internal lane). */
+  /** The composed fire-caller mint, or undefined (the trusted-local internal lane). */
   readonly fireCallerMint?: ScheduleFireCallerMint;
   readonly logger: Logger;
 }
@@ -280,10 +283,13 @@ export class RunStarter {
     }
     if (existing !== undefined) {
       const executionId = existing.metadata?.id ?? "";
-      logger.info("Schedule fire already has its execution (idempotent retry)", {
-        schedule_id: scheduleId,
-        execution_id: executionId,
-      });
+      logger.info(
+        "Schedule fire already has its execution (idempotent retry)",
+        {
+          schedule_id: scheduleId,
+          execution_id: executionId,
+        },
+      );
       await this.stampLastExecutionId(scheduleId, executionId);
       return { kind: "started", executionId, alreadyExisted: true };
     }
@@ -292,7 +298,11 @@ export class RunStarter {
     // after the idempotency lookup (a found winner needs no credential)
     // and before the create it authenticates. Failure is an
     // infrastructure fault — thrown, so the tick activity retries under
-    // the deterministic name and a manual trigger surfaces it.
+    // the deterministic name and a manual trigger surfaces it — unless
+    // the driver says the refusal is deterministic (the seam's own typed
+    // error: this fire can act as nobody, and no retry changes that), in
+    // which case it is a `refused` outcome like a launch gate's: the
+    // streak counts it and pauses the schedule with the reason.
     let fireCaller: CallerIdentity | undefined;
     if (this.deps.fireCallerMint !== undefined) {
       try {
@@ -301,6 +311,14 @@ export class RunStarter {
           scheduleId,
         );
       } catch (error) {
+        if (error instanceof ScheduleFireCallerRefusedError) {
+          logger.error("Schedule fire refused by the fire-caller mint", {
+            schedule_id: scheduleId,
+            org,
+            reason: error.message,
+          });
+          return { kind: "refused", reason: error.message };
+        }
         throw new Error(
           `mint schedule fire caller for ${scheduleId}: ${error instanceof Error ? error.message : String(error)}`,
           { cause: error },
@@ -311,7 +329,12 @@ export class RunStarter {
     let created: AgentExecution;
     try {
       created = await this.deps.executions.create(
-        this.buildExecutionRequest(schedule, resolved.agent, executionName, nominalFireTime),
+        this.buildExecutionRequest(
+          schedule,
+          resolved.agent,
+          executionName,
+          nominalFireTime,
+        ),
         fireCaller,
       );
     } catch (error) {