octoflow-core 1.0.0

package/dist/runtime/orchestration/pack/protocol.js

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { OctoFlowError } from "../../../domain/errors/index.js";
+const DELEGATION_PROTOCOL_VERSION = 1;
+const DelegationEntrySchema = z.object({
+  worker: z.string().min(1),
+  task: z.string().min(1),
+  strategy: z.enum(["sequential", "parallel"]).optional(),
+  timeoutMs: z.number().positive().optional(),
+  priority: z.enum(["high", "normal", "low"]).optional()
+}).passthrough();
+const DelegationPayloadSchema = z.object({
+  protocolVersion: z.literal(DELEGATION_PROTOCOL_VERSION),
+  entries: z.array(DelegationEntrySchema)
+});
+function parseDelegationPayload(value) {
+  const versioned = DelegationPayloadSchema.safeParse(value);
+  if (versioned.success) {
+    return { entries: versioned.data.entries };
+  }
+  return null;
+}
+function buildDelegationPayload(entries) {
+  return { protocolVersion: DELEGATION_PROTOCOL_VERSION, entries };
+}
+class DelegationProtocolMismatchError extends OctoFlowError {
+  expected;
+  received;
+  constructor(received) {
+    super(
+      "DELEGATION_PROTOCOL_MISMATCH",
+      `Pack delegation payload uses protocolVersion=${String(received)}, expected ${DELEGATION_PROTOCOL_VERSION}. Upgrade the driver or the leader prompt.`,
+      { expected: DELEGATION_PROTOCOL_VERSION, received: String(received) }
+    );
+    this.name = "DelegationProtocolMismatchError";
+    this.expected = DELEGATION_PROTOCOL_VERSION;
+    this.received = received;
+  }
+}
+export {
+  DELEGATION_PROTOCOL_VERSION,
+  DelegationEntrySchema,
+  DelegationPayloadSchema,
+  DelegationProtocolMismatchError,
+  buildDelegationPayload,
+  parseDelegationPayload
+};
+//# sourceMappingURL=protocol.js.map

package/dist/runtime/orchestration/pack/protocol.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/runtime/orchestration/pack/protocol.ts"],
+  "sourcesContent": ["/**\n * Pack delegation protocol.\n *\n * The Pack leader tells workers what to do by emitting a delegation payload\n * in its response. This module gives the payload a **versioned** schema so\n * every driver (fenced-block today, native tool-call in the future) agrees\n * on the same canonical shape.\n *\n * Versioning rules:\n *\n *   * Additive fields keep `protocolVersion: 1`.\n *   * A breaking change bumps `DELEGATION_PROTOCOL_VERSION`. Drivers must\n *     refuse to parse payloads whose `protocolVersion` does not match the\n *     version they were compiled against.\n *\n * The versioned JSON shape is:\n *\n * ```json\n * { \"protocolVersion\": 1, \"entries\": [ { \"worker\": \"...\", \"task\": \"...\" } ] }\n * ```\n */\n\nimport { z } from 'zod';\n\nimport { OctoFlowError } from '../../../domain/errors/index.js';\nimport type { DelegationEntry } from './types.js';\n\n/** Current protocol version. Bump on any breaking change to the payload. */\nexport const DELEGATION_PROTOCOL_VERSION = 1 as const;\n\n/**\n * Canonical entry shape \u2014 mirrors the TS `DelegationEntry` type. We extend\n * the zod schema with `.passthrough()` so forward-compatible additions\n * (e.g. new optional fields in v1.x) survive a round-trip without\n * truncation.\n */\nexport const DelegationEntrySchema: z.ZodType<DelegationEntry> = z\n  .object({\n    worker: z.string().min(1),\n    task: z.string().min(1),\n    strategy: z.enum(['sequential', 'parallel']).optional(),\n    timeoutMs: z.number().positive().optional(),\n    priority: z.enum(['high', 'normal', 'low']).optional(),\n  })\n  .passthrough();\n\n/** Versioned payload used by the structured driver. */\nexport const DelegationPayloadSchema = z.object({\n  protocolVersion: z.literal(DELEGATION_PROTOCOL_VERSION),\n  entries: z.array(DelegationEntrySchema),\n});\n\nexport type DelegationPayload = z.infer<typeof DelegationPayloadSchema>;\n\n/**\n * Parse a JSON-deserialized value as the versioned payload shape. Returns\n * `{ entries }` with a uniform shape, or `null` when the input does not match\n * the versioned schema.\n *\n * Throwing an explicit protocol-version mismatch (rather than `null`) lets\n * callers surface a useful error to the leader instead of silently\n * dropping the round.\n */\nexport function parseDelegationPayload(\n  value: unknown\n): { entries: DelegationEntry[] } | null {\n  const versioned = DelegationPayloadSchema.safeParse(value);\n  if (versioned.success) {\n    return { entries: versioned.data.entries };\n  }\n  return null;\n}\n\n/**\n * Build a versioned payload ready to be JSON-stringified.\n */\nexport function buildDelegationPayload(\n  entries: DelegationEntry[]\n): DelegationPayload {\n  return { protocolVersion: DELEGATION_PROTOCOL_VERSION, entries };\n}\n\n/**\n * Thrown when a versioned payload arrives whose `protocolVersion` is not\n * the one this build understands.\n */\nexport class DelegationProtocolMismatchError extends OctoFlowError {\n  readonly expected: number;\n  readonly received: unknown;\n  constructor(received: unknown) {\n    super(\n      'DELEGATION_PROTOCOL_MISMATCH',\n      `Pack delegation payload uses protocolVersion=${String(received)}, ` +\n        `expected ${DELEGATION_PROTOCOL_VERSION}. Upgrade the driver or the leader prompt.`,\n      { expected: DELEGATION_PROTOCOL_VERSION, received: String(received) }\n    );\n    this.name = 'DelegationProtocolMismatchError';\n    this.expected = DELEGATION_PROTOCOL_VERSION;\n    this.received = received;\n  }\n}\n"],
+  "mappings": "AAsBA,SAAS,SAAS;AAElB,SAAS,qBAAqB;AAIvB,MAAM,8BAA8B;AAQpC,MAAM,wBAAoD,EAC9D,OAAO;AAAA,EACN,QAAQ,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EACxB,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EACtB,UAAU,EAAE,KAAK,CAAC,cAAc,UAAU,CAAC,EAAE,SAAS;AAAA,EACtD,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS;AAAA,EAC1C,UAAU,EAAE,KAAK,CAAC,QAAQ,UAAU,KAAK,CAAC,EAAE,SAAS;AACvD,CAAC,EACA,YAAY;AAGR,MAAM,0BAA0B,EAAE,OAAO;AAAA,EAC9C,iBAAiB,EAAE,QAAQ,2BAA2B;AAAA,EACtD,SAAS,EAAE,MAAM,qBAAqB;AACxC,CAAC;AAaM,SAAS,uBACd,OACuC;AACvC,QAAM,YAAY,wBAAwB,UAAU,KAAK;AACzD,MAAI,UAAU,SAAS;AACrB,WAAO,EAAE,SAAS,UAAU,KAAK,QAAQ;AAAA,EAC3C;AACA,SAAO;AACT;AAKO,SAAS,uBACd,SACmB;AACnB,SAAO,EAAE,iBAAiB,6BAA6B,QAAQ;AACjE;AAMO,MAAM,wCAAwC,cAAc;AAAA,EACxD;AAAA,EACA;AAAA,EACT,YAAY,UAAmB;AAC7B;AAAA,MACE;AAAA,MACA,gDAAgD,OAAO,QAAQ,CAAC,cAClD,2BAA2B;AAAA,MACzC,EAAE,UAAU,6BAA6B,UAAU,OAAO,QAAQ,EAAE;AAAA,IACtE;AACA,SAAK,OAAO;AACZ,SAAK,WAAW;AAChB,SAAK,WAAW;AAAA,EAClB;AACF;",
+  "names": []
+}

package/dist/runtime/orchestration/pack/registry.d.ts

@@ -0,0 +1,12 @@
+import type { WorkerEntry } from './types.js';
+export declare class WorkerRegistry {
+    private readonly entries;
+    register(entry: WorkerEntry): void;
+    unregister(name: string): void;
+    get(name: string): WorkerEntry | undefined;
+    has(name: string): boolean;
+    all(): WorkerEntry[];
+    size(): number;
+    findBySkill(tag: string): WorkerEntry[];
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/runtime/orchestration/pack/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/runtime/orchestration/pack/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;IAE1D,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IAIlC,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI9B,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAI1C,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B,GAAG,IAAI,WAAW,EAAE;IAIpB,IAAI,IAAI,MAAM;IAId,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,EAAE;CAKxC"}

package/dist/runtime/orchestration/pack/registry.js

@@ -0,0 +1,30 @@
+class WorkerRegistry {
+  entries = /* @__PURE__ */ new Map();
+  register(entry) {
+    this.entries.set(entry.name, entry);
+  }
+  unregister(name) {
+    this.entries.delete(name);
+  }
+  get(name) {
+    return this.entries.get(name);
+  }
+  has(name) {
+    return this.entries.has(name);
+  }
+  all() {
+    return [...this.entries.values()];
+  }
+  size() {
+    return this.entries.size;
+  }
+  findBySkill(tag) {
+    return this.all().filter(
+      (e) => (e.skills ?? []).some((s) => s.tags?.includes(tag))
+    );
+  }
+}
+export {
+  WorkerRegistry
+};
+//# sourceMappingURL=registry.js.map

package/dist/runtime/orchestration/pack/registry.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/runtime/orchestration/pack/registry.ts"],
+  "sourcesContent": ["import type { WorkerEntry } from './types.js';\n\nexport class WorkerRegistry {\n  private readonly entries = new Map<string, WorkerEntry>();\n\n  register(entry: WorkerEntry): void {\n    this.entries.set(entry.name, entry);\n  }\n\n  unregister(name: string): void {\n    this.entries.delete(name);\n  }\n\n  get(name: string): WorkerEntry | undefined {\n    return this.entries.get(name);\n  }\n\n  has(name: string): boolean {\n    return this.entries.has(name);\n  }\n\n  all(): WorkerEntry[] {\n    return [...this.entries.values()];\n  }\n\n  size(): number {\n    return this.entries.size;\n  }\n\n  findBySkill(tag: string): WorkerEntry[] {\n    return this.all().filter((e) =>\n      (e.skills ?? []).some((s) => s.tags?.includes(tag))\n    );\n  }\n}\n"],
+  "mappings": "AAEO,MAAM,eAAe;AAAA,EACT,UAAU,oBAAI,IAAyB;AAAA,EAExD,SAAS,OAA0B;AACjC,SAAK,QAAQ,IAAI,MAAM,MAAM,KAAK;AAAA,EACpC;AAAA,EAEA,WAAW,MAAoB;AAC7B,SAAK,QAAQ,OAAO,IAAI;AAAA,EAC1B;AAAA,EAEA,IAAI,MAAuC;AACzC,WAAO,KAAK,QAAQ,IAAI,IAAI;AAAA,EAC9B;AAAA,EAEA,IAAI,MAAuB;AACzB,WAAO,KAAK,QAAQ,IAAI,IAAI;AAAA,EAC9B;AAAA,EAEA,MAAqB;AACnB,WAAO,CAAC,GAAG,KAAK,QAAQ,OAAO,CAAC;AAAA,EAClC;AAAA,EAEA,OAAe;AACb,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA,EAEA,YAAY,KAA4B;AACtC,WAAO,KAAK,IAAI,EAAE;AAAA,MAAO,CAAC,OACvB,EAAE,UAAU,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,MAAM,SAAS,GAAG,CAAC;AAAA,IACpD;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/runtime/orchestration/pack/run.d.ts

@@ -0,0 +1,5 @@
+import type { FlowConfig, LoopConfig, PackRunParams, PackRunResult, RunEvent } from '../run/types.js';
+import type { PackLike } from './types.js';
+export declare function runPack(pack: PackLike, params: PackRunParams, defaultFlow?: FlowConfig, defaultLoop?: LoopConfig, onRunEvent?: (event: RunEvent) => void | Promise<void>): Promise<PackRunResult>;
+export declare function runPackStream(pack: PackLike, params: PackRunParams, defaultFlow?: FlowConfig, defaultLoop?: LoopConfig, onRunEvent?: (event: RunEvent) => void | Promise<void>): AsyncGenerator<RunEvent>;
+//# sourceMappingURL=run.d.ts.map

package/dist/runtime/orchestration/pack/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../../src/runtime/orchestration/pack/run.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAGV,UAAU,EACV,UAAU,EAGV,aAAa,EACb,aAAa,EACb,QAAQ,EACT,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,QAAQ,EAAc,MAAM,YAAY,CAAC;AAoEvD,wBAAsB,OAAO,CAC3B,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,aAAa,EACrB,WAAW,CAAC,EAAE,UAAU,EACxB,WAAW,CAAC,EAAE,UAAU,EACxB,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GACrD,OAAO,CAAC,aAAa,CAAC,CA0BxB;AAED,wBAAuB,aAAa,CAClC,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,aAAa,EACrB,WAAW,CAAC,EAAE,UAAU,EACxB,WAAW,CAAC,EAAE,UAAU,EACxB,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GACrD,cAAc,CAAC,QAAQ,CAAC,CAwB1B"}

package/dist/runtime/orchestration/pack/run.js

@@ -0,0 +1,103 @@
+import crypto from "node:crypto";
+import { extractRunMessageText } from "../../../utils/extract-text.js";
+import {
+  drainRunStream,
+  runOrchestrationStream
+} from "../run/orchestration-stream.js";
+import { resolveLoopConfig } from "../run/resolve-loop-config.js";
+import { createPackDispatcher, executeFlow } from "./flow.js";
+function packResultToTaskResult(result) {
+  if (result.kind === "task") {
+    return {
+      kind: "task",
+      contextId: result.contextId,
+      taskId: result.taskId,
+      task: result.task
+    };
+  }
+  return {
+    kind: "task",
+    contextId: result.contextId,
+    taskId: crypto.randomUUID(),
+    task: {
+      id: crypto.randomUUID(),
+      kind: "task",
+      contextId: result.contextId ?? "",
+      status: { state: "completed" }
+    }
+  };
+}
+function toPackLoopResult(base, packResult) {
+  return {
+    ...base,
+    rounds: packResult?.rounds,
+    delegationRounds: packResult?.delegationRounds ?? 0
+  };
+}
+function createPackExecutor(pack, state, flow) {
+  return async (message, contextId, _iteration) => {
+    if (flow) {
+      const stepOutput = await executeFlow(pack, message, contextId, flow);
+      return stepOutput.bridgeResult ?? packResultToTaskResult({
+        kind: "message",
+        contextId,
+        message: {
+          kind: "message",
+          messageId: crypto.randomUUID(),
+          role: "agent",
+          parts: [{ kind: "text", text: stepOutput.text }]
+        }
+      });
+    }
+    const result = await pack.sendMessage({ message, contextId });
+    state.lastPackResult = result;
+    return packResultToTaskResult(result);
+  };
+}
+async function runPack(pack, params, defaultFlow, defaultLoop, onRunEvent) {
+  const contextId = params.contextId ?? crypto.randomUUID();
+  const loopConfig = resolveLoopConfig(defaultLoop, params.loop);
+  const flow = params.flow ?? defaultFlow;
+  const state = {};
+  const executor = createPackExecutor(pack, state, flow);
+  return drainRunStream(
+    runOrchestrationStream({
+      contextId,
+      message: params.message == null ? void 0 : extractRunMessageText(params.message),
+      loop: loopConfig,
+      flow,
+      tasks: params.tasks,
+      executor,
+      flowDispatcher: flow ? createPackDispatcher(pack) : void 0,
+      missingInputMessage: "run() requires either `message`, `flow`, or `tasks`",
+      mapLoopResult: (base) => toPackLoopResult(base, state.lastPackResult),
+      mapTaskResult: (base) => ({ ...base, delegationRounds: 0 }),
+      onEvent: onRunEvent
+    })
+  );
+}
+async function* runPackStream(pack, params, defaultFlow, defaultLoop, onRunEvent) {
+  const contextId = params.contextId ?? crypto.randomUUID();
+  const loopConfig = resolveLoopConfig(defaultLoop, params.loop);
+  const flow = params.flow ?? defaultFlow;
+  const state = {};
+  const executor = createPackExecutor(pack, state, flow);
+  yield* runOrchestrationStream({
+    contextId,
+    message: params.message == null ? void 0 : extractRunMessageText(params.message),
+    loop: loopConfig,
+    flow,
+    tasks: params.tasks,
+    executor,
+    flowDispatcher: flow ? createPackDispatcher(pack) : void 0,
+    missingInputMessage: "runStream() requires either `message`, `flow`, or `tasks`",
+    mapLoopResult: (base) => toPackLoopResult(base, state.lastPackResult),
+    mapTaskResult: (base) => ({ ...base, delegationRounds: 0 }),
+    onEvent: onRunEvent
+  });
+}
+export {
+  runPack,
+  runPackStream
+};
+//# sourceMappingURL=run.js.map

package/dist/runtime/orchestration/pack/run.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/runtime/orchestration/pack/run.ts"],
+  "sourcesContent": ["import crypto from 'node:crypto';\n\nimport { extractRunMessageText } from '../../../utils/extract-text.js';\nimport {\n  drainRunStream,\n  runOrchestrationStream,\n} from '../run/orchestration-stream.js';\nimport { resolveLoopConfig } from '../run/resolve-loop-config.js';\nimport type {\n  BridgeLoopResult,\n  BridgeTaskResult,\n  FlowConfig,\n  LoopConfig,\n  LoopExecutor,\n  PackLoopResult,\n  PackRunParams,\n  PackRunResult,\n  RunEvent,\n} from '../run/types.js';\nimport { createPackDispatcher, executeFlow } from './flow.js';\nimport type { PackLike, PackResult } from './types.js';\n\nfunction packResultToTaskResult(result: PackResult): BridgeTaskResult {\n  if (result.kind === 'task') {\n    return {\n      kind: 'task',\n      contextId: result.contextId,\n      taskId: result.taskId,\n      task: result.task,\n    };\n  }\n  return {\n    kind: 'task',\n    contextId: result.contextId,\n    taskId: crypto.randomUUID(),\n    task: {\n      id: crypto.randomUUID(),\n      kind: 'task',\n      contextId: result.contextId ?? '',\n      status: { state: 'completed' },\n    },\n  };\n}\n\nfunction toPackLoopResult(\n  base: BridgeLoopResult,\n  packResult?: PackResult\n): PackLoopResult {\n  return {\n    ...base,\n    rounds: packResult?.rounds,\n    delegationRounds: packResult?.delegationRounds ?? 0,\n  };\n}\n\ninterface PackExecutorState {\n  lastPackResult?: PackResult;\n}\n\nfunction createPackExecutor(\n  pack: PackLike,\n  state: PackExecutorState,\n  flow?: FlowConfig\n): LoopExecutor {\n  return async (message, contextId, _iteration) => {\n    if (flow) {\n      const stepOutput = await executeFlow(pack, message, contextId, flow);\n      return (\n        stepOutput.bridgeResult ??\n        packResultToTaskResult({\n          kind: 'message',\n          contextId,\n          message: {\n            kind: 'message',\n            messageId: crypto.randomUUID(),\n            role: 'agent',\n            parts: [{ kind: 'text', text: stepOutput.text }],\n          },\n        })\n      );\n    }\n\n    const result = await pack.sendMessage({ message, contextId });\n    state.lastPackResult = result;\n    return packResultToTaskResult(result);\n  };\n}\n\nexport async function runPack(\n  pack: PackLike,\n  params: PackRunParams,\n  defaultFlow?: FlowConfig,\n  defaultLoop?: LoopConfig,\n  onRunEvent?: (event: RunEvent) => void | Promise<void>\n): Promise<PackRunResult> {\n  const contextId = params.contextId ?? crypto.randomUUID();\n  const loopConfig = resolveLoopConfig(defaultLoop, params.loop);\n  const flow = params.flow ?? defaultFlow;\n  const state: PackExecutorState = {};\n  const executor = createPackExecutor(pack, state, flow);\n\n  return drainRunStream(\n    runOrchestrationStream<PackLoopResult>({\n      contextId,\n      message:\n        params.message == null\n          ? undefined\n          : extractRunMessageText(params.message),\n      loop: loopConfig,\n      flow,\n      tasks: params.tasks,\n      executor,\n      flowDispatcher: flow ? createPackDispatcher(pack) : undefined,\n      missingInputMessage:\n        'run() requires either `message`, `flow`, or `tasks`',\n      mapLoopResult: (base) => toPackLoopResult(base, state.lastPackResult),\n      mapTaskResult: (base) => ({ ...base, delegationRounds: 0 }),\n      onEvent: onRunEvent,\n    })\n  );\n}\n\nexport async function* runPackStream(\n  pack: PackLike,\n  params: PackRunParams,\n  defaultFlow?: FlowConfig,\n  defaultLoop?: LoopConfig,\n  onRunEvent?: (event: RunEvent) => void | Promise<void>\n): AsyncGenerator<RunEvent> {\n  const contextId = params.contextId ?? crypto.randomUUID();\n  const loopConfig = resolveLoopConfig(defaultLoop, params.loop);\n  const flow = params.flow ?? defaultFlow;\n  const state: PackExecutorState = {};\n  const executor = createPackExecutor(pack, state, flow);\n\n  yield* runOrchestrationStream<PackLoopResult>({\n    contextId,\n    message:\n      params.message == null\n        ? undefined\n        : extractRunMessageText(params.message),\n    loop: loopConfig,\n    flow,\n    tasks: params.tasks,\n    executor,\n    flowDispatcher: flow ? createPackDispatcher(pack) : undefined,\n    missingInputMessage:\n      'runStream() requires either `message`, `flow`, or `tasks`',\n    mapLoopResult: (base) => toPackLoopResult(base, state.lastPackResult),\n    mapTaskResult: (base) => ({ ...base, delegationRounds: 0 }),\n    onEvent: onRunEvent,\n  });\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/runtime/orchestration/pack/structured-driver.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Structured delegation driver.
+ *
+ * Parses the versioned delegation shape emitted inside a fenced `delegate`
+ * block:
+ *
+ * ```
+ * ```delegate
+ * {
+ *   "protocolVersion": 1,
+ *   "entries": [ { "worker": "analyst", "task": "audit module X" } ]
+ * }
+ * ```
+ * ```
+ *
+ * The versioned shape (explicit `protocolVersion`) gives the driver a
+ * deterministic rollover path: bump {@link DELEGATION_PROTOCOL_VERSION} and
+ * refuse old payloads. The driver composes {@link FencedBlockDriver} as its
+ * fallback for non-versioned JSON object forms, and the manifest prompt is
+ * augmented so the leader knows the versioned shape is accepted.
+ */
+import type { DelegationDriver, DelegationParseResult, WorkerEntry } from './types.js';
+export declare class StructuredDelegationDriver implements DelegationDriver {
+    private readonly fallback;
+    constructor(fallback?: DelegationDriver);
+    parse(responseText: string): DelegationParseResult;
+    buildManifest(workers: WorkerEntry[]): string;
+    buildCorrectionPrompt(raw: string, error: string): string;
+}
+//# sourceMappingURL=structured-driver.d.ts.map

package/dist/runtime/orchestration/pack/structured-driver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured-driver.d.ts","sourceRoot":"","sources":["../../../../src/runtime/orchestration/pack/structured-driver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAQH,OAAO,KAAK,EACV,gBAAgB,EAChB,qBAAqB,EACrB,WAAW,EACZ,MAAM,YAAY,CAAC;AAEpB,qBAAa,0BAA2B,YAAW,gBAAgB;IAE/D,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,GAAE,gBAA0C;IAGvE,KAAK,CAAC,YAAY,EAAE,MAAM,GAAG,qBAAqB;IAwDlD,aAAa,CAAC,OAAO,EAAE,WAAW,EAAE,GAAG,MAAM;IAY7C,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM;CAG1D"}

package/dist/runtime/orchestration/pack/structured-driver.js

@@ -0,0 +1,67 @@
+import { FencedBlockDriver } from "./driver.js";
+import {
+  DELEGATION_PROTOCOL_VERSION,
+  DelegationProtocolMismatchError,
+  parseDelegationPayload
+} from "./protocol.js";
+class StructuredDelegationDriver {
+  constructor(fallback = new FencedBlockDriver()) {
+    this.fallback = fallback;
+  }
+  fallback;
+  parse(responseText) {
+    const hasBlock = /```delegate[ \t]*\r?\n/m.test(responseText);
+    if (!hasBlock) return { kind: "none" };
+    const match = responseText.match(
+      /```delegate[ \t]*\r?\n([\s\S]*?)\n```(?!`)/
+    );
+    if (!match) {
+      return this.fallback.parse(responseText);
+    }
+    const body = match[1] ?? "";
+    let value;
+    try {
+      value = JSON.parse(body);
+    } catch (err) {
+      return {
+        kind: "malformed",
+        raw: body,
+        error: `Invalid JSON: ${String(err)}`
+      };
+    }
+    if (typeof value === "object" && value !== null && "protocolVersion" in value && value.protocolVersion !== DELEGATION_PROTOCOL_VERSION) {
+      const err = new DelegationProtocolMismatchError(
+        value.protocolVersion
+      );
+      return { kind: "malformed", raw: body, error: err.message };
+    }
+    if (Array.isArray(value)) {
+      return {
+        kind: "malformed",
+        raw: body,
+        error: "Delegation payload must be the versioned object shape"
+      };
+    }
+    const parsed = parseDelegationPayload(value);
+    if (!parsed) return this.fallback.parse(responseText);
+    return { kind: "ok", entries: parsed.entries };
+  }
+  buildManifest(workers) {
+    return [
+      this.fallback.buildManifest(workers),
+      "",
+      `Protocol version: ${DELEGATION_PROTOCOL_VERSION}`,
+      "You may also emit the versioned payload shape:",
+      "```delegate",
+      `{"protocolVersion":${DELEGATION_PROTOCOL_VERSION},"entries":[{"worker":"<name>","task":"<description>"}]}`,
+      "```"
+    ].join("\n");
+  }
+  buildCorrectionPrompt(raw, error) {
+    return this.fallback.buildCorrectionPrompt(raw, error);
+  }
+}
+export {
+  StructuredDelegationDriver
+};
+//# sourceMappingURL=structured-driver.js.map

package/dist/runtime/orchestration/pack/structured-driver.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/runtime/orchestration/pack/structured-driver.ts"],
+  "sourcesContent": ["/**\n * Structured delegation driver.\n *\n * Parses the versioned delegation shape emitted inside a fenced `delegate`\n * block:\n *\n * ```\n * ```delegate\n * {\n *   \"protocolVersion\": 1,\n *   \"entries\": [ { \"worker\": \"analyst\", \"task\": \"audit module X\" } ]\n * }\n * ```\n * ```\n *\n * The versioned shape (explicit `protocolVersion`) gives the driver a\n * deterministic rollover path: bump {@link DELEGATION_PROTOCOL_VERSION} and\n * refuse old payloads. The driver composes {@link FencedBlockDriver} as its\n * fallback for non-versioned JSON object forms, and the manifest prompt is\n * augmented so the leader knows the versioned shape is accepted.\n */\n\nimport { FencedBlockDriver } from './driver.js';\nimport {\n  DELEGATION_PROTOCOL_VERSION,\n  DelegationProtocolMismatchError,\n  parseDelegationPayload,\n} from './protocol.js';\nimport type {\n  DelegationDriver,\n  DelegationParseResult,\n  WorkerEntry,\n} from './types.js';\n\nexport class StructuredDelegationDriver implements DelegationDriver {\n  constructor(\n    private readonly fallback: DelegationDriver = new FencedBlockDriver()\n  ) {}\n\n  parse(responseText: string): DelegationParseResult {\n    // 1. Look for a fenced `delegate` block \u2014 same regex as FencedBlockDriver\n    //    so prompt templates stay valid.\n    const hasBlock = /```delegate[ \\t]*\\r?\\n/m.test(responseText);\n    if (!hasBlock) return { kind: 'none' };\n\n    const match = responseText.match(\n      /```delegate[ \\t]*\\r?\\n([\\s\\S]*?)\\n```(?!`)/\n    );\n    if (!match) {\n      // Unterminated block \u2014 defer to the fallback's consistent error text.\n      return this.fallback.parse(responseText);\n    }\n\n    const body = match[1] ?? '';\n    let value: unknown;\n    try {\n      value = JSON.parse(body);\n    } catch (err) {\n      return {\n        kind: 'malformed',\n        raw: body,\n        error: `Invalid JSON: ${String(err)}`,\n      };\n    }\n\n    // 2. Version check: if the payload is an object with `protocolVersion`,\n    //    reject mismatched versions loudly so operators surface the bump.\n    if (\n      typeof value === 'object' &&\n      value !== null &&\n      'protocolVersion' in (value as Record<string, unknown>) &&\n      (value as Record<string, unknown>).protocolVersion !==\n        DELEGATION_PROTOCOL_VERSION\n    ) {\n      const err = new DelegationProtocolMismatchError(\n        (value as Record<string, unknown>).protocolVersion\n      );\n      return { kind: 'malformed', raw: body, error: err.message };\n    }\n\n    // 3. Parse the versioned payload. Bare arrays are rejected \u2014 the driver\n    //    forms defer to the fallback driver so community-specific variants\n    //    keep their existing behaviour.\n    if (Array.isArray(value)) {\n      return {\n        kind: 'malformed',\n        raw: body,\n        error: 'Delegation payload must be the versioned object shape',\n      };\n    }\n    const parsed = parseDelegationPayload(value);\n    if (!parsed) return this.fallback.parse(responseText);\n    return { kind: 'ok', entries: parsed.entries };\n  }\n\n  buildManifest(workers: WorkerEntry[]): string {\n    return [\n      this.fallback.buildManifest(workers),\n      '',\n      `Protocol version: ${DELEGATION_PROTOCOL_VERSION}`,\n      'You may also emit the versioned payload shape:',\n      '```delegate',\n      `{\"protocolVersion\":${DELEGATION_PROTOCOL_VERSION},\"entries\":[{\"worker\":\"<name>\",\"task\":\"<description>\"}]}`,\n      '```',\n    ].join('\\n');\n  }\n\n  buildCorrectionPrompt(raw: string, error: string): string {\n    return this.fallback.buildCorrectionPrompt(raw, error);\n  }\n}\n"],
+  "mappings": "AAsBA,SAAS,yBAAyB;AAClC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAOA,MAAM,2BAAuD;AAAA,EAClE,YACmB,WAA6B,IAAI,kBAAkB,GACpE;AADiB;AAAA,EAChB;AAAA,EADgB;AAAA,EAGnB,MAAM,cAA6C;AAGjD,UAAM,WAAW,0BAA0B,KAAK,YAAY;AAC5D,QAAI,CAAC,SAAU,QAAO,EAAE,MAAM,OAAO;AAErC,UAAM,QAAQ,aAAa;AAAA,MACzB;AAAA,IACF;AACA,QAAI,CAAC,OAAO;AAEV,aAAO,KAAK,SAAS,MAAM,YAAY;AAAA,IACzC;AAEA,UAAM,OAAO,MAAM,CAAC,KAAK;AACzB,QAAI;AACJ,QAAI;AACF,cAAQ,KAAK,MAAM,IAAI;AAAA,IACzB,SAAS,KAAK;AACZ,aAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK;AAAA,QACL,OAAO,iBAAiB,OAAO,GAAG,CAAC;AAAA,MACrC;AAAA,IACF;AAIA,QACE,OAAO,UAAU,YACjB,UAAU,QACV,qBAAsB,SACrB,MAAkC,oBACjC,6BACF;AACA,YAAM,MAAM,IAAI;AAAA,QACb,MAAkC;AAAA,MACrC;AACA,aAAO,EAAE,MAAM,aAAa,KAAK,MAAM,OAAO,IAAI,QAAQ;AAAA,IAC5D;AAKA,QAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,aAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK;AAAA,QACL,OAAO;AAAA,MACT;AAAA,IACF;AACA,UAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAI,CAAC,OAAQ,QAAO,KAAK,SAAS,MAAM,YAAY;AACpD,WAAO,EAAE,MAAM,MAAM,SAAS,OAAO,QAAQ;AAAA,EAC/C;AAAA,EAEA,cAAc,SAAgC;AAC5C,WAAO;AAAA,MACL,KAAK,SAAS,cAAc,OAAO;AAAA,MACnC;AAAA,MACA,qBAAqB,2BAA2B;AAAA,MAChD;AAAA,MACA;AAAA,MACA,sBAAsB,2BAA2B;AAAA,MACjD;AAAA,IACF,EAAE,KAAK,IAAI;AAAA,EACb;AAAA,EAEA,sBAAsB,KAAa,OAAuB;AACxD,WAAO,KAAK,SAAS,sBAAsB,KAAK,KAAK;AAAA,EACvD;AACF;",
+  "names": []
+}