create-windy 0.6.12 → 0.6.15

package/template/apps/server/src/agent-workflow/drizzle-delegated-tool-authorization.ts

@@ -0,0 +1,155 @@
+import { createHash } from "node:crypto";
+import { agentWorkflowBudgetReservations } from "@southwind-ai/database";
+import { and, eq } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { canonicalJson } from "./canonical-json.js";
+import type { DelegatedAgentToolAuthorizationPort } from "./delegated-tool-authorization.js";
+import type { ProductionDelegationAuthorization } from "./delegation-execution-authorization.js";
+import { requireDelegation } from "./drizzle-delegation-lifecycle.js";
+import type { AgentWorkflowRepository } from "./repository.js";
+import { workflowId } from "./service-support.js";
+
+export class DrizzleDelegatedAgentToolAuthorization implements DelegatedAgentToolAuthorizationPort {
+  constructor(
+    private readonly db: NodePgDatabase,
+    private readonly repository: AgentWorkflowRepository,
+    private readonly authorization: ProductionDelegationAuthorization,
+  ) {}
+
+  async authorize(
+    input: Parameters<DelegatedAgentToolAuthorizationPort["authorize"]>[0],
+  ) {
+    const row = await requireDelegation(this.db, input.delegation.delegationId);
+    const snapshot = await this.repository.getSnapshot(row.parentRunId);
+    const release = snapshot
+      ? await this.repository.getRelease(snapshot.run.releaseId)
+      : undefined;
+    const nodeRun = snapshot?.nodeRuns.find(
+      ({ nodeRunId }) => nodeRunId === row.parentNodeRunId,
+    );
+    const node = release?.definition.nodes.find(
+      ({ id }) => id === row.parentNodeId,
+    );
+    if (
+      !snapshot ||
+      !release ||
+      !nodeRun ||
+      !node ||
+      node.type !== "subagent" ||
+      nodeRun.nodeType !== "subagent" ||
+      nodeRun.nodeId !== node.id ||
+      row.status !== "running" ||
+      row.grantJson.status !== "running" ||
+      row.childAgentRunId !== input.runId ||
+      node.operationKey !== input.operationKey
+    ) {
+      throw denied("DELEGATED_AGENT_GRANT_INACTIVE");
+    }
+    await this.assertActiveReservation(row);
+    const current = await this.authorization.authorize({
+      parentRunId: row.parentRunId,
+      parentNodeId: row.parentNodeId,
+      parentNodeRunId: row.parentNodeRunId,
+      capabilityKey: node.capabilityKey,
+      operationKey: node.operationKey,
+      allowedToolKeys: node.allowedToolKeys,
+      requiredFeatureKeys: node.requiredFeatureKeys,
+      requiredPermissionKeys: node.requiredPermissionKeys,
+      ...(node.allowedLicenseVersions
+        ? { allowedLicenseVersions: node.allowedLicenseVersions }
+        : {}),
+      budget: node.budget,
+      workspacePolicyKey: node.workspacePolicyKey,
+      scopePolicyKey: node.scopePolicyKey,
+      parentActorId: snapshot.run.actorId,
+      parentScopeDigest: snapshot.run.scopeDigest,
+      parentAuthorizationSnapshotDigest:
+        snapshot.run.authorizationSnapshotDigest,
+      parentToolPolicyDigest: snapshot.run.toolPolicyDigest,
+      parentWorkspacePolicyDigest: snapshot.run.workspacePolicyDigest,
+      parentExecutionPolicyDigest: snapshot.run.executionPolicyDigest,
+      context: input.context,
+      idempotencyKey: row.idempotencyKey,
+      signal: input.signal,
+    });
+    this.assertCurrentGrant(input, row.grantJson, current);
+  }
+
+  private async assertActiveReservation(
+    row: Awaited<ReturnType<typeof requireDelegation>>,
+  ) {
+    const [reservation] = await this.db
+      .select()
+      .from(agentWorkflowBudgetReservations)
+      .where(
+        and(
+          eq(
+            agentWorkflowBudgetReservations.reservationId,
+            workflowId("workflow_budget", row.delegationId),
+          ),
+          eq(agentWorkflowBudgetReservations.delegationId, row.delegationId),
+          eq(agentWorkflowBudgetReservations.parentRunId, row.parentRunId),
+          eq(
+            agentWorkflowBudgetReservations.parentNodeRunId,
+            row.parentNodeRunId,
+          ),
+        ),
+      )
+      .limit(1);
+    if (!reservation || reservation.status !== "active") {
+      throw denied("DELEGATED_AGENT_BUDGET_INACTIVE");
+    }
+  }
+
+  private assertCurrentGrant(
+    input: Parameters<DelegatedAgentToolAuthorizationPort["authorize"]>[0],
+    grant: Awaited<ReturnType<typeof requireDelegation>>["grantJson"],
+    current: Awaited<
+      ReturnType<ProductionDelegationAuthorization["authorize"]>
+    >,
+  ) {
+    const persisted = input.delegation;
+    const ceiling = grant.capabilityCeiling;
+    const policy = current.policy;
+    if (
+      !ceiling.allowedToolKeys.includes(input.toolKey) ||
+      !persisted.requiredFeatureKeys.length ||
+      !persisted.requiredPermissionKeys.length ||
+      persisted.delegationId !== grant.delegationId ||
+      persisted.policyDigest !== ceiling.policyDigest ||
+      persisted.workspacePolicyKey !== ceiling.workspacePolicyKey ||
+      persisted.workspaceId !== ceiling.workspaceId ||
+      persisted.scopeDigest !== ceiling.scopeDigest ||
+      persisted.scopePolicyDigest !== ceiling.scopePolicyDigest ||
+      persisted.capabilityKey !== ceiling.capabilityKey ||
+      persisted.budgetDigest !== digest(grant.budget) ||
+      !same(persisted.requiredFeatureKeys, ceiling.requiredFeatureKeys) ||
+      !same(persisted.requiredPermissionKeys, ceiling.requiredPermissionKeys) ||
+      current.workspaceId !== ceiling.workspaceId ||
+      policy.capabilityKey !== ceiling.capabilityKey ||
+      policy.workspacePolicyKey !== ceiling.workspacePolicyKey ||
+      policy.childScopeDigest !== ceiling.scopeDigest ||
+      policy.scopePolicyDigest !== ceiling.scopePolicyDigest ||
+      policy.authorizationSnapshotDigest !==
+        ceiling.authorizationSnapshotDigest ||
+      policy.runPolicyDigest !== ceiling.runPolicyDigest ||
+      !same(policy.allowedToolKeys, ceiling.allowedToolKeys) ||
+      !same(policy.requiredFeatureKeys, ceiling.requiredFeatureKeys) ||
+      !same(policy.requiredPermissionKeys, ceiling.requiredPermissionKeys)
+    ) {
+      throw denied("DELEGATED_AGENT_GRANT_REVOKED");
+    }
+  }
+}
+
+function same(left: readonly string[], right: readonly string[]) {
+  return canonicalJson([...left].sort()) === canonicalJson([...right].sort());
+}
+
+function digest(value: unknown) {
+  return `sha256:${createHash("sha256").update(canonicalJson(value)).digest("hex")}`;
+}
+
+function denied(code: string) {
+  return new Error(code);
+}

package/template/apps/server/src/agent-workflow/drizzle-delegation-completion.ts

@@ -0,0 +1,84 @@
+import type {
+  AgentWorkflowNodeResultReceipt,
+  AgentWorkflowUsage,
+} from "@southwind-ai/shared";
+import type { ModuleAiJsonValue } from "@southwind-ai/server-sdk";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { AgentWorkflowArtifactSourceAuthorizationPort } from "./artifact-source-authorization.js";
+import { canonicalChildDelivery } from "./delegation-child-delivery.js";
+import {
+  appendDelegationEvent,
+  bindDelegationChild,
+  type DelegationRow,
+  requireParentRun,
+} from "./drizzle-delegation-lifecycle.js";
+import type { AgentWorkflowRepository } from "./repository.js";
+
+export async function completeDelegation(input: {
+  readonly db: NodePgDatabase;
+  readonly repository: AgentWorkflowRepository;
+  readonly row: DelegationRow;
+  readonly inspected: {
+    readonly result: ModuleAiJsonValue;
+    readonly resultDigest: string;
+    readonly cumulativeUsage: AgentWorkflowUsage;
+    readonly executionEvidence: NonNullable<
+      AgentWorkflowNodeResultReceipt["executionEvidence"]
+    >;
+  };
+  readonly artifactSources?: AgentWorkflowArtifactSourceAuthorizationPort;
+}) {
+  const childAgentRunId = input.row.childAgentRunId;
+  if (!childAgentRunId) throw new Error("DELEGATION_CHILD_RUN_MISSING");
+  const usage: AgentWorkflowUsage = {
+    ...input.inspected.cumulativeUsage,
+    subagents: 1,
+  };
+  const delivery = canonicalChildDelivery(
+    input.inspected.result,
+    input.inspected.resultDigest,
+  );
+  const parent = await requireParentRun(input.db, input.row.parentRunId);
+  if (delivery.artifacts.length && !input.artifactSources) {
+    throw new Error("CHILD_ARTIFACT_AUTHORIZATION_UNAVAILABLE");
+  }
+  for (const artifact of delivery.artifacts) {
+    await input.artifactSources!.requireCurrent({
+      artifact,
+      actorId: parent.actorId,
+      frozenScope: input.row.grantJson.capabilityCeiling.scopeSnapshot,
+    });
+  }
+  await bindDelegationChild({
+    db: input.db,
+    row: input.row,
+    childRunId: childAgentRunId,
+    status: "completed",
+    outputArtifacts: delivery.artifacts,
+  });
+  await appendDelegationEvent({
+    repository: input.repository,
+    runId: input.row.parentRunId,
+    idempotencyKey: `delegation-completed:${input.row.delegationId}`,
+    data: {
+      type: "workflow.delegation-completed",
+      delegationId: input.row.delegationId,
+      parentNodeId: input.row.parentNodeId,
+      parentNodeRunId: input.row.parentNodeRunId,
+      childSessionId: input.row.childSessionId,
+      childAgentRunId,
+      artifactIds: delivery.artifacts.map(({ artifactId }) => artifactId),
+    },
+  });
+  return {
+    status: "completed" as const,
+    childAgentRunId,
+    resultDigest: input.inspected.resultDigest,
+    artifacts: delivery.artifacts,
+    ...(delivery.smallResult === undefined
+      ? {}
+      : { smallResult: delivery.smallResult }),
+    cumulativeUsage: usage,
+    executionEvidence: input.inspected.executionEvidence,
+  };
+}

package/template/apps/server/src/agent-workflow/drizzle-delegation-lifecycle.ts

@@ -0,0 +1,139 @@
+import {
+  agentWorkflowDelegations,
+  agentWorkflowRuns,
+} from "@southwind-ai/database";
+import type { AgentDelegationGrant } from "@southwind-ai/shared";
+import { and, eq } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { AgentWorkflowRepository } from "./repository.js";
+import { workflowEvent } from "./service-support.js";
+import { canonicalJson } from "./canonical-json.js";
+
+export type DelegationRow = typeof agentWorkflowDelegations.$inferSelect;
+
+export async function requireDelegation(
+  db: NodePgDatabase,
+  delegationId: string,
+) {
+  const [row] = await db
+    .select()
+    .from(agentWorkflowDelegations)
+    .where(eq(agentWorkflowDelegations.delegationId, delegationId))
+    .limit(1);
+  if (!row) throw new Error("DELEGATION_NOT_FOUND");
+  return row;
+}
+
+export async function requireParentRun(db: NodePgDatabase, runId: string) {
+  const [row] = await db
+    .select()
+    .from(agentWorkflowRuns)
+    .where(eq(agentWorkflowRuns.runId, runId))
+    .limit(1);
+  if (!row) throw new Error("PARENT_RUN_NOT_FOUND");
+  return row;
+}
+
+export async function bindDelegationChild(input: {
+  readonly db: NodePgDatabase;
+  readonly row: DelegationRow;
+  readonly childRunId: string;
+  readonly status: AgentDelegationGrant["status"];
+  readonly outputArtifacts?: AgentDelegationGrant["outputArtifacts"];
+}) {
+  if (
+    input.row.childAgentRunId &&
+    input.row.childAgentRunId !== input.childRunId
+  ) {
+    throw new Error("DELEGATION_CHILD_RUN_CONFLICT");
+  }
+  const grant = {
+    ...input.row.grantJson,
+    childAgentRunId: input.childRunId,
+    status: input.status,
+    ...(input.outputArtifacts
+      ? { outputArtifacts: structuredClone(input.outputArtifacts) }
+      : {}),
+  } as AgentDelegationGrant;
+  if (
+    input.row.childAgentRunId === input.childRunId &&
+    input.row.status === input.status &&
+    canonicalJson(input.row.grantJson) === canonicalJson(grant)
+  ) {
+    return input.row;
+  }
+  const [updated] = await input.db
+    .update(agentWorkflowDelegations)
+    .set({
+      childAgentRunId: input.childRunId,
+      status: input.status,
+      grantJson: grant,
+      updatedAt: Date.now(),
+    })
+    .where(
+      and(
+        eq(agentWorkflowDelegations.delegationId, input.row.delegationId),
+        eq(agentWorkflowDelegations.childSessionId, input.row.childSessionId),
+        eq(agentWorkflowDelegations.updatedAt, input.row.updatedAt),
+      ),
+    )
+    .returning();
+  if (updated) return updated;
+  const current = await requireDelegation(input.db, input.row.delegationId);
+  if (
+    current.childAgentRunId !== input.childRunId ||
+    current.status !== input.status ||
+    canonicalJson(current.grantJson) !== canonicalJson(grant)
+  ) {
+    throw new Error("DELEGATION_CHILD_RUN_CAS_CONFLICT");
+  }
+  return current;
+}
+
+export async function appendDelegationEvent(input: {
+  readonly repository: AgentWorkflowRepository;
+  readonly runId: string;
+  readonly idempotencyKey: string;
+  readonly data: Parameters<typeof workflowEvent>[0]["data"];
+}) {
+  const event = workflowEvent({
+    runId: input.runId,
+    idempotencyKey: input.idempotencyKey,
+    at: new Date().toISOString(),
+    data: input.data,
+  });
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const snapshot = await input.repository.getSnapshot(input.runId);
+    if (!snapshot) throw new Error("PARENT_RUN_NOT_FOUND");
+    if (await input.repository.findEvent(event.eventId)) return;
+    try {
+      return await input.repository.commit({
+        runId: input.runId,
+        expectedSequence: snapshot.headSequence,
+        events: [event],
+      });
+    } catch (error) {
+      if (attempt === 2) throw error;
+    }
+  }
+}
+
+export function ensureChildLinkedEvent(input: {
+  readonly repository: AgentWorkflowRepository;
+  readonly row: DelegationRow;
+  readonly childAgentRunId: string;
+}) {
+  return appendDelegationEvent({
+    repository: input.repository,
+    runId: input.row.parentRunId,
+    idempotencyKey: `delegation-linked:${input.row.delegationId}`,
+    data: {
+      type: "workflow.delegation-child-linked",
+      delegationId: input.row.delegationId,
+      parentNodeId: input.row.parentNodeId,
+      parentNodeRunId: input.row.parentNodeRunId,
+      childSessionId: input.row.childSessionId,
+      childAgentRunId: input.childAgentRunId,
+    },
+  });
+}

package/template/apps/server/src/agent-workflow/drizzle-delegation-port.ts

@@ -0,0 +1,288 @@
+import type { AgentDelegationGrant } from "@southwind-ai/shared";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { RequestActor } from "../guards.js";
+import { restoreServerScopeContext } from "../data-access/context.js";
+import type { SessionId } from "../agent/session-log/domain.js";
+import type { SessionEventLogService } from "../agent/session-log/service.js";
+import { CanonicalAgentWorkflowModelExecutionPort } from "./canonical-agent-run-port.js";
+import type { ProductionDelegationAuthorization } from "./delegation-execution-authorization.js";
+import type { DrizzleWorkflowBudgetLedger } from "./drizzle-budget-ledger.js";
+import type { AgentWorkflowDelegationExecutionPort } from "./node-execution-ports.js";
+import type { AgentWorkflowRepository } from "./repository.js";
+import { workflowId } from "./service-support.js";
+import { EMPTY_AGENT_WORKFLOW_USAGE } from "./usage.js";
+import type { AgentWorkflowArtifactSourceAuthorizationPort } from "./artifact-source-authorization.js";
+import { completeDelegation } from "./drizzle-delegation-completion.js";
+import {
+  appendDelegationEvent,
+  bindDelegationChild,
+  ensureChildLinkedEvent,
+  requireDelegation,
+  requireParentRun,
+} from "./drizzle-delegation-lifecycle.js";
+
+export class DrizzleAgentWorkflowDelegationExecutionPort implements AgentWorkflowDelegationExecutionPort {
+  constructor(
+    private readonly db: NodePgDatabase,
+    private readonly repository: AgentWorkflowRepository,
+    private readonly ledger: DrizzleWorkflowBudgetLedger,
+    private readonly sessions: SessionEventLogService,
+    private readonly agentRuns: CanonicalAgentWorkflowModelExecutionPort,
+    private readonly authorization: ProductionDelegationAuthorization,
+    private readonly resolveActor: (
+      actorId: string,
+    ) => Promise<RequestActor | undefined>,
+    private readonly artifactSources?: AgentWorkflowArtifactSourceAuthorizationPort,
+  ) {}
+
+  async reserve(
+    input: Parameters<AgentWorkflowDelegationExecutionPort["reserve"]>[0],
+  ) {
+    const authorized = await this.authorization.authorize(input);
+    const snapshot = await this.repository.getSnapshot(input.parentRunId);
+    if (!snapshot || snapshot.run.actorId !== input.parentActorId) {
+      throw new Error("DELEGATION_PARENT_RUN_FORBIDDEN");
+    }
+    const delegationId = workflowId(
+      "workflow_delegation",
+      input.parentNodeRunId,
+    );
+    const reservationId = workflowId("workflow_budget", delegationId);
+    const childSessionId = workflowId("session", delegationId) as SessionId;
+    const grant: AgentDelegationGrant = {
+      delegationId,
+      parentRunId: input.parentRunId,
+      parentNodeId: input.parentNodeId,
+      parentNodeRunId: input.parentNodeRunId,
+      childSessionId,
+      capabilityCeiling: {
+        capabilityKey: authorized.policy.capabilityKey,
+        allowedToolKeys: [...authorized.policy.allowedToolKeys],
+        requiredFeatureKeys: [...authorized.policy.requiredFeatureKeys],
+        requiredPermissionKeys: [...authorized.policy.requiredPermissionKeys],
+        ...(input.allowedLicenseVersions
+          ? { allowedLicenseVersions: [...input.allowedLicenseVersions].sort() }
+          : {}),
+        workspacePolicyKey: input.workspacePolicyKey,
+        workspaceId: authorized.workspaceId,
+        scopeSnapshot: authorized.policy.childScopeSnapshot,
+        scopePolicyDigest: authorized.policy.scopePolicyDigest,
+        policyDigest: authorized.policy.policyDigest,
+        authorizationProofId: authorized.policy.authorizationProofId,
+        runPolicyDigest: authorized.policy.runPolicyDigest,
+        scopeDigest: authorized.policy.childScopeDigest,
+        authorizationSnapshotDigest:
+          authorized.policy.authorizationSnapshotDigest,
+      },
+      budget: structuredClone(input.budget),
+      status: "created",
+      outputArtifacts: [],
+    };
+    const reserved = await this.ledger.createDelegationWithReservation({
+      grant,
+      parentNodeRunId: input.parentNodeRunId,
+      delegationIdempotencyKey: input.idempotencyKey,
+      reservation: {
+        reservationId,
+        parentRunId: input.parentRunId,
+        parentNodeRunId: input.parentNodeRunId,
+        delegationId,
+        requested: input.budget,
+        expectedLedgerVersion: snapshot.run.version,
+        idempotencyKey: `delegation:${input.idempotencyKey}`,
+        authorizationFence: {
+          proofId: workflowId("workflow_auth_proof", input.idempotencyKey),
+          actorId: input.parentActorId,
+          authorizationSnapshotDigest: input.parentAuthorizationSnapshotDigest,
+          runPolicyDigest: input.parentExecutionPolicyDigest,
+          checkedAt: new Date().toISOString(),
+          expiresAt: new Date(Date.now() + 60_000).toISOString(),
+        },
+        deadlineAt: snapshot.run.deadlineAt,
+      },
+      createdAt: new Date().toISOString(),
+    });
+    if (reserved.outcome !== "reserved" && reserved.outcome !== "replayed") {
+      throw new Error(`DELEGATION_${reserved.outcome.toUpperCase()}`);
+    }
+    try {
+      await appendDelegationEvent({
+        repository: this.repository,
+        runId: input.parentRunId,
+        idempotencyKey: `delegation-created:${delegationId}`,
+        data: {
+          type: "workflow.delegation-created",
+          delegationId,
+          parentNodeId: input.parentNodeId,
+          parentNodeRunId: input.parentNodeRunId,
+          childSessionId,
+        },
+      });
+    } catch (error) {
+      const reservation = reserved.reservation;
+      const released = await this.ledger.release({
+        reservationId: reservation.reservationId,
+        parentRunId: reservation.parentRunId,
+        expectedReservationVersion: reservation.version,
+        reasonCode: "DELEGATION_EVENT_UNAVAILABLE",
+        authorizationSnapshotDigest: reservation.authorizationSnapshotDigest,
+        runPolicyDigest: reservation.runPolicyDigest,
+        releasedAt: new Date().toISOString(),
+      });
+      if (!["released", "replayed"].includes(released.outcome)) {
+        throw new Error("DELEGATION_RESERVATION_COMPENSATION_PENDING", {
+          cause: error,
+        });
+      }
+      throw error;
+    }
+    return { delegationId, budgetReservationId: reservationId, childSessionId };
+  }
+
+  async start(
+    input: Parameters<AgentWorkflowDelegationExecutionPort["start"]>[0],
+  ) {
+    const row = await requireDelegation(this.db, input.delegationId);
+    if (
+      row.childSessionId !== input.childSessionId ||
+      row.parentRunId !== input.effectFence.runId ||
+      row.parentNodeRunId !== input.effectFence.nodeRunId ||
+      row.delegationId !== input.effectFence.delegationId ||
+      workflowId("workflow_budget", row.delegationId) !==
+        input.effectFence.budgetReservationId ||
+      input.effectFence.effectKind !== "subagent" ||
+      input.effectFence.adapter.coordinate !== input.childSessionId
+    ) {
+      throw new Error("DELEGATION_SESSION_MISMATCH");
+    }
+    if (row.childAgentRunId) {
+      await ensureChildLinkedEvent({
+        repository: this.repository,
+        row,
+        childAgentRunId: row.childAgentRunId,
+      });
+      return { childAgentRunId: row.childAgentRunId };
+    }
+    await this.sessions.create({
+      sessionId: input.childSessionId as SessionId,
+      createdEventId:
+        `session_event_${workflowId("child", input.delegationId)}` as `session_event_${string}`,
+      governance: {
+        actorId: (await requireParentRun(this.db, row.parentRunId)).actorId,
+        scopeDigest: row.grantJson.capabilityCeiling
+          .scopeDigest as `sha256:${string}`,
+      },
+    });
+    const parent = await requireParentRun(this.db, row.parentRunId);
+    const actor = await this.resolveActor(parent.actorId);
+    if (!actor) throw new Error("DELEGATION_ACTOR_REVOKED");
+    const scopeContext = restoreServerScopeContext(
+      row.grantJson.capabilityCeiling.scopeSnapshot,
+    );
+    const delegatedActor: RequestActor = {
+      ...actor,
+      scopeContext,
+      dataAccess: scopeContext,
+    };
+    const context = await this.authorization.createGuardContext(
+      delegatedActor,
+      input.signal,
+    );
+    const started = await this.agentRuns.startRun({
+      operationKey: input.operationKey,
+      value: input.value,
+      idempotencyKey: input.idempotencyKey,
+      context,
+      sessionId: input.childSessionId,
+      signal: input.signal,
+      grant: row.grantJson,
+    });
+    const bound = await bindDelegationChild({
+      db: this.db,
+      row,
+      childRunId: started.runId,
+      status: "running",
+    });
+    await ensureChildLinkedEvent({
+      repository: this.repository,
+      row: bound,
+      childAgentRunId: started.runId,
+    });
+    return { childAgentRunId: started.runId };
+  }
+
+  async reconcile(
+    input: Parameters<AgentWorkflowDelegationExecutionPort["reconcile"]>[0],
+  ) {
+    const row = await requireDelegation(this.db, input.delegationId);
+    if (!row.childAgentRunId) return { status: "running" as const };
+    const inspected = await this.agentRuns.inspect(
+      row.childAgentRunId,
+      EMPTY_AGENT_WORKFLOW_USAGE,
+      input.signal,
+    );
+    if (inspected.status === "running") return inspected;
+    if (inspected.status !== "completed") {
+      await bindDelegationChild({
+        db: this.db,
+        row,
+        childRunId: row.childAgentRunId,
+        status: inspected.status,
+      });
+      await appendDelegationEvent({
+        repository: this.repository,
+        runId: row.parentRunId,
+        idempotencyKey: `delegation-${inspected.status}:${row.delegationId}`,
+        data: {
+          type: "workflow.delegation-failed",
+          delegationId: row.delegationId,
+          parentNodeId: row.parentNodeId,
+          parentNodeRunId: row.parentNodeRunId,
+          childSessionId: row.childSessionId,
+          childAgentRunId: row.childAgentRunId,
+          safeCode: `CHILD_AGENT_${inspected.status.toUpperCase()}`,
+        },
+      });
+      return {
+        status: inspected.status,
+        safeCode: `CHILD_AGENT_${inspected.status.toUpperCase()}`,
+        ...(inspected.cumulativeUsage
+          ? {
+              cumulativeUsage: {
+                ...inspected.cumulativeUsage,
+                subagents: 1,
+              },
+            }
+          : {}),
+      };
+    }
+    return completeDelegation({
+      db: this.db,
+      repository: this.repository,
+      row,
+      inspected,
+      artifactSources: this.artifactSources,
+    });
+  }
+
+  async cancel(delegationId: string, signal: AbortSignal) {
+    const row = await requireDelegation(this.db, delegationId);
+    await appendDelegationEvent({
+      repository: this.repository,
+      runId: row.parentRunId,
+      idempotencyKey: `delegation-cancel:${delegationId}`,
+      data: {
+        type: "workflow.delegation-cancel-requested",
+        delegationId,
+        parentNodeId: row.parentNodeId,
+        parentNodeRunId: row.parentNodeRunId,
+        childSessionId: row.childSessionId,
+        ...(row.childAgentRunId
+          ? { childAgentRunId: row.childAgentRunId }
+          : {}),
+      },
+    });
+    if (!row.childAgentRunId) return true;
+    return this.agentRuns.cancelRun(row.childAgentRunId, signal);
+  }
+}