@loomhelm/multi-task-flow 0.0.0-stage → 0.2.1

package/toolkit/skills/multi-task-flow/lib/errors.ts

@@ -0,0 +1,19 @@
+export class ContractError extends Error {
+  constructor(
+    public code: string,
+    message: string,
+    public exitCode = 2,
+    public details?: unknown,
+  ) {
+    super(message);
+  }
+}
+
+export function requireCondition(
+  condition: unknown,
+  code: string,
+  message: string,
+  exitCode = 2,
+): asserts condition {
+  if (!condition) throw new ContractError(code, message, exitCode);
+}

package/toolkit/skills/multi-task-flow/lib/execution-profile.ts

@@ -0,0 +1,102 @@
+import {
+  executionProfile,
+  recommendedExecutionProfile,
+  type ExecutionProfile,
+  type Ledger,
+} from "../lib/schema";
+import { requireCondition } from "../lib/errors";
+
+export const RECOMMENDATION_VERSION = "kind-v1";
+export type ProfileCapabilities = { model: string; thinking: string[] }[];
+export function validateProfileCapability(
+  profile: ExecutionProfile,
+  capabilities: ProfileCapabilities,
+): ExecutionProfile {
+  const pair = executionProfile.parse(profile);
+  requireCondition(
+    capabilities.some(
+      (item) =>
+        item.model === pair.model && item.thinking.includes(pair.thinking),
+    ),
+    "PROFILE_UNAVAILABLE",
+    `Unsupported execution profile: ${pair.model}/${pair.thinking}`,
+    3,
+  );
+  return pair;
+}
+export function effectiveProfile(
+  ledger: Ledger,
+  target: { execution_profile?: ExecutionProfile | null },
+): ExecutionProfile {
+  const profile = target.execution_profile ?? ledger.config.execution_profile;
+  requireCondition(
+    profile,
+    "PROFILE_MIGRATION_REQUIRED",
+    "Run has no execution profile; explicitly migrate it before writing",
+    4,
+  );
+  return executionProfile.parse(profile);
+}
+export function profileFreezeReason(
+  ledger: Ledger,
+  targetType: "group" | "task",
+  targetId: string,
+): string | null {
+  const bound =
+    targetType === "group"
+      ? ledger.groups.find((item) => item.id === targetId)?.agent_thread_id
+      : ledger.tasks.find((item) => item.id === targetId)?.thread_id;
+  if (bound) return "对话已创建";
+  // Only confirmed failure releases the request freeze; unknown remains reserved.
+  const operation = ledger.operations.find(
+    (item) =>
+      item.kind === "dispatch" &&
+      item.target_id === targetId &&
+      (item.request.target_type === "group" ? "group" : "task") ===
+        targetType &&
+      !!item.request.native_request_id &&
+      item.status !== "failed",
+  );
+  return operation ? "对话创建请求已提交，须先对账" : null;
+}
+export function materializeRecommendation(
+  ledger: Ledger,
+  target: Ledger["tasks"][number] | Ledger["groups"][number],
+): void {
+  if (
+    target.execution_profile !== null &&
+    target.execution_profile !== undefined
+  )
+    return;
+  const kind = "kind" in target ? target.kind : "other";
+  target.execution_profile = recommendedExecutionProfile(
+    kind,
+    effectiveProfile(ledger, target),
+  );
+  target.execution_profile_source = "recommendation";
+  target.execution_profile_rule = RECOMMENDATION_VERSION;
+}
+
+export function profileProjection(
+  ledger: Ledger,
+  targetType: "group" | "task",
+  target: { id: string; execution_profile?: ExecutionProfile | null },
+) {
+  return {
+    effective_execution_profile: ledger.config.execution_profile
+      ? effectiveProfile(ledger, target)
+      : null,
+    profile_freeze_reason: profileFreezeReason(ledger, targetType, target.id),
+  };
+}
+
+export function profileMigrationWarnings(ledger: Ledger): { reason: string }[] {
+  return ledger.config.execution_profile
+    ? []
+    : [
+        {
+          reason:
+            "旧运行尚未迁移执行配置；当前只读，请使用 execution-profile-migrate 显式指定默认模型和思考等级。",
+        },
+      ];
+}

package/toolkit/skills/multi-task-flow/lib/graph.ts

@@ -0,0 +1,68 @@
+import { ContractError, requireCondition } from "../lib/errors";
+
+export interface GraphEdge {
+  from: string;
+  to: string;
+}
+
+export function topologicalOrder(ids: string[], edges: GraphEdge[]): string[] {
+  const nodes = new Set(ids);
+  requireCondition(
+    nodes.size === ids.length,
+    "DUPLICATE_ID",
+    "Graph node IDs must be unique",
+  );
+  const incoming = new Map(ids.map((id) => [id, 0]));
+  const next = new Map(ids.map((id) => [id, [] as string[]]));
+  for (const edge of edges) {
+    requireCondition(
+      nodes.has(edge.from) && nodes.has(edge.to),
+      "UNKNOWN_NODE",
+      "Edge references an unknown node",
+    );
+    incoming.set(edge.to, incoming.get(edge.to)! + 1);
+    next.get(edge.from)!.push(edge.to);
+  }
+  const queue = ids.filter((id) => incoming.get(id) === 0);
+  const ordered: string[] = [];
+  while (queue.length) {
+    const id = queue.shift()!;
+    ordered.push(id);
+    for (const child of next.get(id)!) {
+      incoming.set(child, incoming.get(child)! - 1);
+      if (incoming.get(child) === 0) queue.push(child);
+    }
+  }
+  if (ordered.length !== ids.length)
+    throw new ContractError("CYCLE", "Dependencies contain a cycle");
+  return ordered;
+}
+
+export function validateGrouping(
+  atoms: { id: string; task_id: string }[],
+  edges: { from_atom_id: string; to_atom_id: string }[],
+): void {
+  topologicalOrder(
+    atoms.map((atom) => atom.id),
+    edges.map((edge) => ({ from: edge.from_atom_id, to: edge.to_atom_id })),
+  );
+  const owner = new Map(atoms.map((atom) => [atom.id, atom.task_id]));
+  const taskIds = [...new Set(atoms.map((atom) => atom.task_id))];
+  const taskEdges = edges
+    .map((edge) => ({
+      from: owner.get(edge.from_atom_id)!,
+      to: owner.get(edge.to_atom_id)!,
+    }))
+    .filter((edge) => edge.from !== edge.to);
+  topologicalOrder(taskIds, taskEdges);
+  const positions = new Map(atoms.map((atom, index) => [atom.id, index]));
+  for (const edge of edges) {
+    if (owner.get(edge.from_atom_id) === owner.get(edge.to_atom_id)) {
+      requireCondition(
+        positions.get(edge.from_atom_id)! < positions.get(edge.to_atom_id)!,
+        "ATOM_ORDER",
+        "Atoms within a task must follow dependency order",
+      );
+    }
+  }
+}

package/toolkit/skills/multi-task-flow/lib/ledger-maintenance.ts

@@ -0,0 +1,327 @@
+import { join } from "node:path";
+import { z } from "zod";
+import { readRegularNoFollow } from "../../bin/modules/visual/secure_io";
+import { LedgerStore, safeId } from "../lib/store";
+import { ServiceState } from "../lib/service-state";
+import { digest, verifyRelease } from "../lib/service-release";
+import { ledgerContract, requireLedgerCompatibility } from "../lib/service-contract";
+import {
+  stable,
+  contractMigrationCandidate,
+  contractV3MigrationCandidate,
+  commitMigration,
+  migrationBackupName,
+  verifyMigrationBackup,
+  type LockedLedgerMigrationContext,
+} from "../lib/store-migration";
+import {
+  executionProfile,
+  taskExecutionPolicyDeclarationGaps,
+  TASK_EXECUTION_POLICY_FIELDS,
+  validateTaskExecutionPolicies,
+  validateLedger,
+} from "../lib/schema";
+import { migrateProfile } from "../lib/profile-migration";
+import { ContractError, requireCondition } from "../lib/errors";
+import { readCodexCapabilities } from "../lib/codex-agent-api";
+import {
+  validateProfileCapability,
+  type ProfileCapabilities,
+} from "../lib/execution-profile";
+
+const text = z.string().trim().min(1);
+const sha = z.string().regex(/^[a-f0-9]{64}$/);
+const id = text.refine((value) => {
+  try {
+    safeId(value);
+    return true;
+  } catch {
+    return false;
+  }
+}, "Invalid identifier");
+const operation = z.object({
+  run_id: id,
+  action: z.enum(["contract", "execution-profile"]),
+  execution_profile: executionProfile.optional(),
+});
+function validAction(value: { action: string; execution_profile?: unknown }) {
+  return (
+    (value.action === "execution-profile") ===
+    (value.execution_profile !== undefined)
+  );
+}
+export const maintenanceCheckSchema = operation
+  .strict()
+  .refine(validAction, "Only execution-profile requires execution_profile");
+export const maintenanceApplySchema = operation
+  .extend({
+    expected_owner_thread_id: text,
+    expected_revision: z.number().int().nonnegative(),
+    expected_ledger_sha256: sha,
+    operation_digest: sha,
+    request_id: id,
+    maintenance_thread_id: text,
+    approval_ref: text,
+    reason: text,
+    writers_paused: z.literal(true),
+  })
+  .strict()
+  .refine(validAction, "Only execution-profile requires execution_profile");
+type Operation = z.infer<typeof maintenanceCheckSchema>;
+type Apply = z.infer<typeof maintenanceApplySchema>;
+function readRaw(state: ServiceState, runId: string) {
+  const content = readRegularNoFollow(
+    join(state.paths.data, "runs", safeId(runId), "ledger.json"),
+    state.paths.root,
+  ).toString("utf8");
+  let raw: any;
+  try {
+    raw = JSON.parse(content);
+  } catch {
+    throw new ContractError("LEDGER_UNREADABLE", "Ledger is unreadable", 5);
+  }
+  requireCondition(
+    raw.orchestration_id === runId,
+    "RUN_MISMATCH",
+    "Request refers to another run",
+    3,
+  );
+  validateLedger(raw);
+  return { raw, content };
+}
+function installedManifest(state: ServiceState) {
+  try {
+    return verifyRelease(
+      join(state.paths.releases, state.config().current_build),
+    );
+  } catch {
+    throw new ContractError(
+      "SERVICE_NOT_COMPATIBLE",
+      "Install a verified viewer readable for source and target before migration",
+      3,
+    );
+  }
+}
+function prepare(
+  state: ServiceState,
+  op: Operation,
+  raw: any,
+  content: string,
+) {
+  const ledger = validateLedger(raw);
+  requireCondition(
+    ledger.control.ownership === "bound" && ledger.control.owner_thread_id,
+    "FORBIDDEN",
+    "Maintenance requires an existing bound owner",
+    3,
+  );
+  const taskExecutionPolicyGaps =
+    op.action === "contract" ? taskExecutionPolicyDeclarationGaps(raw) : [];
+  if (op.action === "contract" && ledger.contract_version === 2 && taskExecutionPolicyGaps.length === 0) {
+    try {
+      validateTaskExecutionPolicies(raw.tasks ?? []);
+    } catch (error) {
+      if (error instanceof ContractError)
+        throw new ContractError(
+          "HISTORICAL_LEDGER_READ_ONLY",
+          "Historical task execution policies are semantically invalid; explicit recovery is required",
+          4,
+        );
+      throw error;
+    }
+  }
+  const candidate =
+    op.action === "contract"
+      ? ledger.contract_version === 2 && taskExecutionPolicyGaps.length === 0
+        ? contractV3MigrationCandidate(raw)
+        : contractMigrationCandidate(raw, {
+            allowHistoricalTaskExecutionPolicies: true,
+          })
+      : structuredClone(ledger);
+  if (op.action === "execution-profile") {
+    requireLedgerCompatibility(raw, "write");
+    migrateProfile(candidate, op.execution_profile);
+  }
+  const manifest = installedManifest(state);
+  const pending = ledger.operations
+    .filter((item) => item.status === "claimed" || item.status === "unknown")
+    .map((item) => ({ id: item.id, status: item.status }));
+  const body = {
+    run_id: op.run_id,
+    action: op.action,
+    execution_profile: op.execution_profile ?? null,
+    owner_thread_id: ledger.control.owner_thread_id,
+    revision: ledger.revision,
+    source_contract: ledgerContract(raw),
+    ledger_sha256: digest(content),
+    target_contract: ledgerContract(candidate),
+    target_execution_profile: candidate.config.execution_profile ?? null,
+    installed_build: manifest.build_id,
+    source_readable: manifest.readable.includes(ledgerContract(raw)),
+    target_readable: manifest.readable.includes(ledgerContract(candidate)),
+    pending_operations: pending,
+    task_execution_policy_migration: taskExecutionPolicyGaps.length
+      ? {
+          mode: "declare-null",
+          fields: TASK_EXECUTION_POLICY_FIELDS.filter((field) =>
+            taskExecutionPolicyGaps.some((gap) => gap.missing_fields.includes(field)),
+          ),
+          tasks: taskExecutionPolicyGaps,
+        }
+      : null,
+  };
+  return {
+    candidate,
+    report: { ...body, operation_digest: digest(stable(body)) },
+  };
+}
+export function maintenanceCheck(state: ServiceState, input: unknown) {
+  const op = maintenanceCheckSchema.parse(input);
+  const { raw, content } = readRaw(state, op.run_id);
+  return prepare(state, op, raw, content).report;
+}
+function findPrior(raw: any, request: Apply, canonical: string) {
+  const prior = validateLedger(raw).requests.find(
+    (item) => item.request_id === request.request_id,
+  );
+  if (!prior) return null;
+  requireCondition(
+    prior.command === "ledger-maintenance-apply" &&
+      prior.canonical_input === canonical,
+    "ID_CONFLICT",
+    "Request ID has different content",
+    3,
+  );
+  return prior;
+}
+function replay(
+  context: LockedLedgerMigrationContext,
+  raw: any,
+  request: Apply,
+  canonical: string,
+) {
+  const prior = findPrior(raw, request, canonical);
+  if (!prior) return null;
+  const priorResult = prior.result as Record<string, unknown>;
+  verifyMigrationBackup(
+    context,
+    priorResult.backup,
+    {
+      request_id: request.request_id,
+      command: "ledger-maintenance-apply",
+      canonical_input: canonical,
+    },
+    typeof priorResult.ledger_sha256 === "string"
+      ? priorResult.ledger_sha256
+      : undefined,
+  );
+  return {
+    ok: true,
+    code: "REPLAYED",
+    revision: prior.committed_revision,
+    result: prior.result,
+  };
+}
+export async function maintenanceApply(
+  state: ServiceState,
+  input: unknown,
+  getCapabilities: () => Promise<ProfileCapabilities> = readCodexCapabilities,
+  storeOverride?: LedgerStore,
+) {
+  const request = maintenanceApplySchema.parse(input);
+  const canonical = stable(request);
+  // Network capability lookup stays outside synchronous storage locks. Replays do not need app-server.
+  const first = readRaw(state, request.run_id);
+  const prior = findPrior(first.raw, request, canonical);
+  const capabilities =
+    prior || request.action !== "execution-profile" ? null : await getCapabilities();
+  const store =
+    storeOverride ?? new LedgerStore(state.paths.data, request.run_id);
+  requireCondition(
+    store.rootPath === state.paths.data &&
+      store.runPath === join(state.paths.data, "runs", request.run_id),
+    "RUN_MISMATCH",
+    "Store identity mismatch",
+  );
+  return store.maintain((context: LockedLedgerMigrationContext) => {
+    const { raw, content } = readRaw(state, request.run_id);
+    const repeated = replay(context, raw, request, canonical);
+    if (repeated) return repeated;
+    if (prior)
+      throw new ContractError(
+        "LEDGER_CONFLICT",
+        "Persisted replay request changed before it could be verified",
+        3,
+      );
+    requireCondition(
+      raw.control?.owner_thread_id === request.expected_owner_thread_id &&
+        raw.control?.ownership === "bound",
+      "OWNER_CONFLICT",
+      "Bound owner changed",
+      3,
+    );
+    requireCondition(
+      raw.revision === request.expected_revision,
+      "REVISION_CONFLICT",
+      "Ledger version changed",
+      3,
+    );
+    requireCondition(
+      digest(content) === request.expected_ledger_sha256,
+      "LEDGER_CONFLICT",
+      "Ledger content changed",
+      3,
+    );
+    const { candidate, report } = prepare(state, request, raw, content);
+    requireCondition(
+      report.operation_digest === request.operation_digest,
+      "STALE_MAINTENANCE_CHECK",
+      "Maintenance operation or installed build changed",
+      3,
+    );
+    if (report.pending_operations.length)
+      throw new ContractError(
+        "OPERATIONS_PENDING",
+        "Reconcile unresolved operations before maintenance",
+        3,
+        report,
+      );
+    if (!report.source_readable || !report.target_readable)
+      throw new ContractError(
+        "SERVICE_NOT_COMPATIBLE",
+        "Install a viewer readable for source and target before migration",
+        3,
+        report,
+      );
+    if (capabilities)
+      validateProfileCapability(request.execution_profile!, capabilities);
+    candidate.revision += 1;
+    candidate.updated_at = new Date().toISOString();
+    const backup = migrationBackupName(
+      "ledger-maintenance-apply",
+      request.request_id,
+    );
+    const result = {
+      ...report,
+      revision: candidate.revision,
+      backup,
+      maintenance_thread_id: request.maintenance_thread_id,
+      approval_ref: request.approval_ref,
+      reason: request.reason,
+      writers_paused: true,
+    };
+    candidate.requests.push({
+      request_id: request.request_id,
+      command: "ledger-maintenance-apply",
+      canonical_input: canonical,
+      result,
+      committed_revision: candidate.revision,
+    });
+    commitMigration(context, content, candidate, backup, {
+      request_id: request.request_id,
+      command: "ledger-maintenance-apply",
+      canonical_input: canonical,
+    });
+    return { ok: true, code: "APPLIED", revision: candidate.revision, result };
+  });
+}

package/toolkit/skills/multi-task-flow/lib/legacy-plan-alias.ts

@@ -0,0 +1,8 @@
+export function normalizeRetiredPlanAlias(
+  value: Record<string, unknown>,
+): Record<string, unknown> {
+  const { dev_plan_handoff: retired, ...current } = value;
+  return current.plan_handoff === undefined && retired !== undefined
+    ? { ...current, plan_handoff: retired }
+    : current;
+}

package/toolkit/skills/multi-task-flow/lib/notification-delivery.ts

@@ -0,0 +1,119 @@
+import { createHash, randomUUID } from "node:crypto";
+import { join } from "node:path";
+import { tryLockFile } from "../../bin/modules/core/security_file";
+import { apply, type requestSchema } from "../lib/engine";
+import type { z } from "zod";
+import { ContractError } from "../lib/errors";
+import { validateLedger } from "../lib/schema";
+import type { LedgerStore } from "../lib/store";
+import { sendCodexMessage, type CodexDeliveryResult } from "../lib/codex-agent-api";
+
+type Request = z.infer<typeof requestSchema>;
+function flightLock(store: LedgerStore, notificationId: string) {
+  // Separate from the short ledger lock: held across the provider await. OS
+  // process death releases it, leaving the durable unknown intent to reconcile.
+  store.read();
+  const key = createHash("sha256").update(notificationId).digest("hex");
+  const lock = tryLockFile(join(store.runPath, "locks", `notification-${key}.lock`));
+  if (!lock) throw new ContractError("NOTIFICATION_IN_FLIGHT", "An active sender still owns this notification; do not reconcile or retry", 5);
+  return lock;
+}
+
+export function reconcileNotification(store: LedgerStore, parsed: Request): unknown {
+  const lock = flightLock(store, String(parsed.payload.notification_id));
+  try { return store.update(raw => apply(raw, "notification-reconcile", parsed)); }
+  finally { lock.release(); }
+}
+
+/** Preserve caller identity, atomic CAS and contract2 states without converting
+ * the ledger. A distinct flight lock excludes reconciliation while sending. */
+export async function deliverClaimedNotification(
+  store: LedgerStore,
+  parsed: Request,
+  notificationId: string,
+  prompt: string,
+  send: typeof sendCodexMessage = sendCodexMessage,
+  direct = true,
+): Promise<unknown> {
+  const requestId = direct ? parsed.request_id : `notification-auto-${createHash("sha256").update(JSON.stringify([parsed.run_id, parsed.actor, parsed.request_id, notificationId])).digest("hex")}`;
+  function claim(raw: any, replayOnly: boolean): any {
+    const ledger = validateLedger(raw);
+    const prior = ledger.requests.find(item => item.request_id === requestId);
+    if (!prior && replayOnly) return null;
+    const attemptId = prior ? (prior.result as any).delivery_attempt_id : randomUUID();
+    const result: any = apply(raw, "notification-deliver", {
+      run_id: parsed.run_id, actor: parsed.actor, request_id: requestId,
+      expected_revision: direct ? parsed.expected_revision : ledger.revision,
+      payload: { notification_id: notificationId, delivery_attempt_id: attemptId, outcome: "unknown",
+        provider_receipt: { provider: "codex-app-server", evidence_ref: `codex-app-server:${attemptId}:intent` } },
+    });
+    if (result.code === "REPLAYED") {
+      const final = ledger.requests.find(item => item.request_id === `notification-result-${attemptId}`);
+      // Return the immutable result of THIS attempt, even if a later request
+      // retried it or acknowledged the notification. Never invoke the provider.
+      return { replay: final ? { ok: true, code: "APPLIED", revision: final.committed_revision, result: final.result, replayed: true } : { ...result, replayed: true, next_action: "notification-reconcile" } };
+    }
+    const notice = validateLedger(raw).notifications.find(item => item.id === notificationId)!;
+    return { attemptId, notice };
+  }
+  // Validate cached identity/actor under the ledger lock even during an active
+  // send. A repeated caller can observe its original unknown intent safely.
+  // Never use update for this read: it normalizes historical records on commit,
+  // even when no request exists and the later CAS must reject without writing.
+  const cached: any = claim(store.read(), true);
+  if (cached) return cached.replay;
+  const lock = flightLock(store, notificationId);
+  try {
+    const claimed: any = store.update(raw => claim(raw, false));
+    if (claimed.replay) return claimed.replay;
+    const { attemptId, notice } = claimed;
+    let delivery: CodexDeliveryResult;
+    try {
+      delivery = await send({ recipient_thread_id: notice.recipient_thread_id, prompt, request_id: attemptId });
+    } catch (error) {
+      throw new ContractError("RECONCILIATION_REQUIRED", `Notification attempt ${attemptId} remains unknown: ${String(error)}`, 5);
+    }
+    return store.update(raw => {
+      const current = validateLedger(raw);
+      const active = current.notifications.find(item => item.id === notice.id);
+      if (!active || active.last_attempt_id !== attemptId || active.delivery_status !== "unknown" || active.last_reconciliation_id !== null)
+        throw new ContractError("RECONCILIATION_REQUIRED", `Delivery receipt for ${attemptId} cannot overwrite a changed notification; reconcile ${delivery.provider_receipt.evidence_ref}`, 5);
+      return apply(raw, "notification-reconcile", {
+        run_id: parsed.run_id, actor: parsed.actor,
+        request_id: `notification-result-${attemptId}`, expected_revision: current.revision,
+        payload: { notification_id: notice.id, reconciliation_id: `result-${attemptId}`,
+          outcome: delivery.outcome, provider_receipt: delivery.provider_receipt,
+          ...(delivery.error ? { error: delivery.error } : {}) },
+      });
+    });
+  } finally { lock.release(); }
+}
+
+/** Claim once, release the OS lock, then let the caller use the desktop tool.
+ * An unknown durable attempt excludes every other sender until reconciliation. */
+export function prepareNativeNotification(
+  store: LedgerStore, parsed: Request, notificationId: string, prompt: string, direct = true,
+): unknown {
+  const requestId = direct ? parsed.request_id : `notification-native-${createHash("sha256").update(JSON.stringify([parsed.run_id, parsed.actor, parsed.request_id, notificationId])).digest("hex")}`;
+  const lock = flightLock(store, notificationId);
+  try {
+    return store.update(raw => {
+      const ledger = validateLedger(raw);
+      const prior = ledger.requests.find(item => item.request_id === requestId);
+      const attemptId = prior ? (prior.result as any).delivery_attempt_id : randomUUID();
+      const notice = ledger.notifications.find(item => item.id === notificationId)!;
+      const promptDigest = createHash("sha256").update(prompt).digest("hex");
+      const result: any = apply(raw, "notification-deliver", {
+        run_id: parsed.run_id, actor: parsed.actor, request_id: requestId,
+        expected_revision: direct ? parsed.expected_revision : ledger.revision,
+        payload: { notification_id: notificationId, delivery_attempt_id: attemptId, outcome: "unknown", prompt_digest: promptDigest,
+        provider_receipt: { provider: "codex-app-tools", evidence_ref: `codex-app-tools:${attemptId}:intent`, recipient_thread_id: notice.recipient_thread_id, prompt_digest: promptDigest } },
+      });
+      return { ...result, replayed: result.code === "REPLAYED", delivery_attempt_id: attemptId, should_send: result.code !== "REPLAYED",
+        next_action: result.code === "REPLAYED" ? "notification-reconcile" : "send_message_to_thread",
+        tool_request: result.code === "REPLAYED" ? null : { threadId: notice.recipient_thread_id, prompt },
+        receipt_command: "notification-reconcile",
+        receipt_identity: { notification_id: notificationId, delivery_attempt_id: attemptId, recipient_thread_id: notice.recipient_thread_id, prompt_digest: promptDigest } };
+    });
+  } finally { lock.release(); }
+}

package/toolkit/skills/multi-task-flow/lib/package-source.ts

@@ -0,0 +1,35 @@
+import { createHash } from 'node:crypto';
+import { cpSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+export const digest = value => createHash('sha256').update(value).digest('hex');
+export function copySkillSources(root, output, { dependencies = false } = {}) {
+  const manifest = JSON.parse(readFileSync(join(root, 'skills/source-manifest.json'), 'utf8'));
+  const files = new Map();
+  const copy = (path, expected) => {
+    const source = resolve(root, path);
+    if (!path.startsWith('skills/') || !source.startsWith(resolve(root, 'skills') + '/')) throw new Error('Unsafe source resource: ' + path);
+    const stat = lstatSync(source);
+    if (!stat.isFile() || stat.isSymbolicLink() || realpathSync(source) !== source || (!path.includes('/node_modules/') && stat.nlink !== 1)) throw new Error('Unsafe source resource: ' + path);
+    const sha256 = digest(readFileSync(source));
+    if (expected && expected !== sha256) throw new Error('Source resource checksum mismatch: ' + path);
+    const target = join(output, path); mkdirSync(dirname(target), { recursive: true, mode: 0o700 }); cpSync(source, target);
+    files.set(path, sha256);
+  };
+  for (const file of [...manifest.files, ...(manifest.additions ?? [])]) copy(file.path, file.installedSha256);
+  for (const path of ['skills/source-manifest.json', 'skills/catalog.json']) copy(path);
+  for (const name of ['index.html','app.js','app.css']) copy('skills/multi-task-flow/dist/' + name);
+  if (dependencies) {
+    const walk = path => {
+      for (const entry of readdirSync(join(root, path), { withFileTypes: true })) {
+        if (entry.name === '.bin' || entry.name === '.cache') continue;
+        const child = path + '/' + entry.name;
+        if (entry.isDirectory()) walk(child); else copy(child);
+      }
+    };
+    for (const path of ['skills/node_modules', 'skills/multi-task-flow/node_modules']) {
+      if (!existsSync(join(root, path))) throw new Error('Prepared dependency directory missing: ' + path);
+      walk(path);
+    }
+  }
+  return Object.fromEntries([...files].sort(([a],[b]) => a.localeCompare(b)));
+}