@yycholla/pi-dynamic-workflows 3.3.0

package/skills/workflow-authoring/examples/bounded-semantic-retry.js

@@ -0,0 +1,56 @@
+export const meta = {
+  name: "bounded_semantic_retry",
+  description: "Separate recoverable transport retries from a visible bounded semantic attempt ledger",
+  phases: [{ title: "Attempt" }],
+};
+
+// ADAPT: define task-owned acceptance, prompts, bounds, and structured result fields.
+const maxSemanticAttempts =
+  args && Number.isInteger(args.maxSemanticAttempts) ? Math.max(1, Math.min(args.maxSemanticAttempts, 5)) : 3;
+const transportRetries =
+  args && Number.isInteger(args.transportRetries) ? Math.max(0, Math.min(args.transportRetries, 3)) : 0;
+const resultSchema = {
+  type: "object",
+  properties: {
+    accepted: { type: "boolean" },
+    answer: { type: "string" },
+    feedback: { type: "string" },
+  },
+  required: ["accepted", "answer", "feedback"],
+};
+const attempts = [];
+let feedback = "";
+let acceptedResult = null;
+
+phase("Attempt");
+for (let attempt = 1; attempt <= maxSemanticAttempts; attempt++) {
+  const result = await agent(
+    `Produce an acceptable answer.${feedback ? ` Address this prior feedback: ${feedback}` : ""}`,
+    {
+      label: `semantic-attempt:${attempt}`,
+      schema: resultSchema,
+      // Runtime retries repeat this same logical call after recoverable execution failures.
+      retries: transportRetries,
+    },
+  );
+  if (result === null) {
+    attempts.push({ attempt, status: "missing", result: null });
+    feedback = "The previous logical attempt produced no usable coverage.";
+    continue;
+  }
+  const status = result.accepted ? "accepted" : "rejected";
+  attempts.push({ attempt, status, result });
+  if (result.accepted) {
+    acceptedResult = result;
+    break;
+  }
+  feedback = result.feedback;
+}
+
+// INVARIANT: semantic exhaustion is returned visibly; it is not presented as success or thrown away.
+return {
+  ok: acceptedResult !== null,
+  exhausted: acceptedResult === null && attempts.length === maxSemanticAttempts,
+  result: acceptedResult,
+  attempts,
+};

package/skills/workflow-authoring/examples/classify-and-act.js

@@ -0,0 +1,67 @@
+export const meta = {
+  name: "classify_and_act",
+  description: "Classify bounded work before routing each item to an appropriate actor",
+  phases: [{ title: "Classify" }, { title: "Act" }],
+};
+
+// ADAPT: validate and bound items, categories, prompts, and schemas for the task.
+const items =
+  args && Array.isArray(args.items) ? args.items : [{ id: "sample", task: "Classify one sample item" }];
+const categories = ["direct", "parallel", "iterative"];
+const instructionsByCategory = {
+  direct: "Handle directly in one focused pass.",
+  parallel: "Divide independent parts, account for each part, then combine them.",
+  iterative: "Work in bounded rounds and stop when the task-specific condition is met.",
+};
+const classificationSchema = {
+  type: "object",
+  properties: {
+    category: { type: "string", enum: categories },
+    reason: { type: "string" },
+  },
+  required: ["category", "reason"],
+};
+const actionSchema = {
+  type: "object",
+  properties: { outcome: { type: "string" } },
+  required: ["outcome"],
+};
+
+phase("Classify");
+const classifications = await parallel(
+  items.map((item, index) => () =>
+    agent(`Classify this item as ${categories.join(", ")}.\n\n${JSON.stringify(item)}`, {
+      label: `classify:${index}:${String(item.id)}`,
+      schema: classificationSchema,
+    }),
+  ),
+);
+const failedClassification = items.flatMap((item, index) =>
+  classifications[index] === null ? [String(item.id)] : [],
+);
+const routed = items.flatMap((item, index) =>
+  classifications[index] === null ? [] : [{ item, classification: classifications[index] }],
+);
+
+// INVARIANT: no routed action starts until the complete classification set exists.
+phase("Act");
+const actions = await parallel(
+  routed.map(({ item, classification }, index) => () =>
+    agent(
+      `${instructionsByCategory[classification.category]}\n\n${JSON.stringify(item)}`,
+      { label: `act:${index}:${String(item.id)}`, schema: actionSchema },
+    ),
+  ),
+);
+const failedAction = routed.flatMap(({ item }, index) => (actions[index] === null ? [String(item.id)] : []));
+
+// INVARIANT: retain identities for failures in either stage.
+return {
+  handled: routed.flatMap(({ item, classification }, index) =>
+    actions[index] === null
+      ? []
+      : [{ id: String(item.id), category: classification.category, result: actions[index] }],
+  ),
+  failed: { classification: failedClassification, action: failedAction },
+  complete: failedClassification.length === 0 && failedAction.length === 0,
+};

package/skills/workflow-authoring/examples/fan-out-and-synthesize.js

@@ -0,0 +1,47 @@
+export const meta = {
+  name: "fan_out_and_synthesize",
+  description: "Run bounded independent work, retain a complete coverage ledger, then synthesize",
+  phases: [{ title: "Fan out" }, { title: "Synthesize" }],
+};
+
+// ADAPT: validate and bound args.work for the task before invoking this workflow.
+const work = args && Array.isArray(args.work) ? args.work : [];
+
+phase("Fan out");
+const fanOutResults = await parallel(
+  work.map((unit, index) => () =>
+    agent(
+      `Complete this independent work unit. Return only evidence relevant to it.\n\n${JSON.stringify(unit)}`,
+      // INVARIANT: index plus a stable task-owned id keeps labels unique.
+      { label: `fanout:${index}:${String(unit.id)}` },
+    ),
+  ),
+);
+
+// INVARIANT: preserve every intended identity before filtering or synthesis.
+const ledger = work.map((unit, index) => ({
+  id: String(unit.id),
+  status: fanOutResults[index] === null ? "failed" : "complete",
+  result: fanOutResults[index],
+}));
+
+phase("Synthesize");
+const synthesis = await agent(
+  `Synthesize the complete fan-out ledger below. Distinguish covered work from failed/missing coverage; do not invent results.\n\n${JSON.stringify(ledger)}`,
+  {
+    label: "synthesize-complete-set",
+    // ADAPT: keep the schema small and aligned with downstream field access.
+    schema: {
+      type: "object",
+      properties: {
+        summary: { type: "string" },
+        coveredIds: { type: "array", items: { type: "string" } },
+        failedIds: { type: "array", items: { type: "string" } },
+      },
+      required: ["summary", "coveredIds", "failedIds"],
+    },
+  },
+);
+
+// INVARIANT: return plain serializable data, including missing-coverage identities.
+return { ledger, synthesis };

package/skills/workflow-authoring/examples/generate-and-filter.js

@@ -0,0 +1,68 @@
+export const meta = {
+  name: "generate_and_filter",
+  description: "Generate divergent candidates, deterministically deduplicate, then apply a rubric",
+  phases: [{ title: "Generate" }, { title: "Filter" }],
+};
+
+// ADAPT: choose the topic, rubric, candidate schema, and a task-appropriate batch bound.
+const topic = args && typeof args.topic === "string" ? args.topic : "candidate ideas";
+const rubric = args && typeof args.rubric === "string" ? args.rubric : "Distinct and fit for purpose";
+const batchCount = args && Number.isInteger(args.batches) ? Math.max(1, Math.min(args.batches, 8)) : 3;
+const maxCandidates =
+  args && Number.isInteger(args.maxCandidates) ? Math.max(1, Math.min(args.maxCandidates, 64)) : 24;
+const generationSchema = {
+  type: "object",
+  properties: { candidates: { type: "array", items: { type: "string" } } },
+  required: ["candidates"],
+};
+const filterSchema = {
+  type: "object",
+  properties: { keep: { type: "boolean" }, reason: { type: "string" } },
+  required: ["keep", "reason"],
+};
+
+phase("Generate");
+const batches = await parallel(
+  Array.from({ length: batchCount }, (_, index) => () =>
+    agent(`Generate divergent candidates for ${topic}. Seek a distinct angle for batch ${index + 1}.`, {
+      label: `generate:${index + 1}`,
+      schema: generationSchema,
+    }),
+  ),
+);
+const failedBatches = batches.flatMap((batch, index) => (batch === null ? [index + 1] : []));
+
+// INVARIANT: JavaScript performs stable, normalized first-wins deduplication before filter calls.
+const seen = new Set();
+const deduplicated = [];
+for (const batch of batches) {
+  for (const candidate of batch?.candidates ?? []) {
+    const key = candidate.trim().toLowerCase();
+    if (key && !seen.has(key)) {
+      seen.add(key);
+      deduplicated.push(candidate);
+    }
+  }
+}
+const candidates = deduplicated.slice(0, maxCandidates);
+const omitted = deduplicated.slice(maxCandidates);
+
+phase("Filter");
+const verdicts = await parallel(
+  candidates.map((candidate, index) => () =>
+    agent(`Apply this rubric: ${rubric}\nCandidate: ${candidate}`, {
+      label: `filter:${index + 1}`,
+      schema: filterSchema,
+    }),
+  ),
+);
+const failedFilters = candidates.flatMap((candidate, index) => (verdicts[index] === null ? [candidate] : []));
+
+return {
+  candidates,
+  omitted,
+  survivors: candidates.filter((_, index) => verdicts[index]?.keep),
+  rejected: candidates.filter((_, index) => verdicts[index] !== null && !verdicts[index].keep),
+  failed: { batches: failedBatches, filters: failedFilters },
+  complete: failedBatches.length === 0 && failedFilters.length === 0,
+};

package/skills/workflow-authoring/examples/loop-until-done.js

@@ -0,0 +1,68 @@
+export const meta = {
+  name: "loop_until_done",
+  description: "Discover unknown-cardinality findings until repeated successful rounds are dry",
+  phases: [{ title: "Discover" }],
+};
+
+// ADAPT: choose the target, stable identity field, schema, dry-round rule, and maximum bound.
+const target = args && typeof args.target === "string" ? args.target : "new findings";
+const maxRounds = args && Number.isInteger(args.maxRounds) ? Math.max(1, Math.min(args.maxRounds, 20)) : 6;
+const consecutiveDry = 2;
+const roundSchema = {
+  type: "object",
+  properties: {
+    findings: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: { id: { type: "string" }, detail: { type: "string" } },
+        required: ["id", "detail"],
+      },
+    },
+  },
+  required: ["findings"],
+};
+const failedRounds = [];
+const knownIds = new Set();
+const findings = [];
+let dryRounds = 0;
+let roundsRun = 0;
+
+phase("Discover");
+while (roundsRun < maxRounds && dryRounds < consecutiveDry) {
+  const roundNumber = roundsRun + 1;
+  const response = await agent(
+    `Find ${target}. Return only findings not represented by these stable IDs: ${JSON.stringify([...knownIds])}`,
+    { label: `discover:${roundNumber}`, schema: roundSchema },
+  );
+  roundsRun++;
+  if (response === null) {
+    // INVARIANT: missing coverage is not evidence that a round was dry or part of a dry streak.
+    failedRounds.push(roundNumber);
+    dryRounds = 0;
+    continue;
+  }
+
+  const fresh = [];
+  for (const finding of response.findings) {
+    if (!knownIds.has(finding.id)) {
+      knownIds.add(finding.id);
+      fresh.push(finding);
+    }
+  }
+  if (fresh.length === 0) dryRounds++;
+  else {
+    dryRounds = 0;
+    findings.push(...fresh);
+  }
+}
+
+// INVARIANT: stable IDs, consecutive successful dry rounds, and maxRounds bound exploration.
+const termination = dryRounds >= consecutiveDry ? "dry" : "max-rounds";
+return {
+  findings,
+  failedRounds,
+  roundsRun,
+  termination,
+  complete: failedRounds.length === 0 && termination === "dry",
+};

package/skills/workflow-authoring/examples/phased-budgets.js

@@ -0,0 +1,75 @@
+export const meta = {
+  name: "phased_budgets",
+  description: "Bound noisy work with named phase budgets and report shared token spending truthfully",
+  phases: [{ title: "Explore" }, { title: "Deliver" }],
+};
+
+// ADAPT: validate the work, choose phase budgets, prompts, schemas, and invocation-level tokenBudget.
+const work = args && Array.isArray(args.work) ? args.work.slice(0, 8) : [{ id: "sample" }];
+const phaseBudget =
+  args && Number.isFinite(args.phaseBudget) ? Math.max(1, Math.min(args.phaseBudget, 100000)) : 2000;
+const resultSchema = {
+  type: "object",
+  properties: { summary: { type: "string" } },
+  required: ["summary"],
+};
+const phases = [];
+
+phase("Explore", { budget: phaseBudget });
+const exploreStart = budget.spent();
+const explored = [];
+const exploreMissing = [];
+const exploreAttempted = work.map((item) => String(item.id));
+for (let index = 0; index < work.length; index++) {
+  const item = work[index];
+  const id = String(item.id);
+  try {
+    const result = await agent(`Explore this bounded work item: ${JSON.stringify(item)}`, {
+      label: `explore:${index}:${id}`,
+      schema: resultSchema,
+    });
+    if (result === null) exploreMissing.push(id);
+    else explored.push({ id, index, result });
+  } catch (error) {
+    if (!error || error.code !== "TOKEN_BUDGET_EXHAUSTED") throw error;
+    // INVARIANT: the soft gate blocks this and later calls; retain every intended identity as missing coverage.
+    exploreMissing.push(...work.slice(index).map((remaining) => String(remaining.id)));
+    break;
+  }
+}
+phases.push({
+  title: "Explore",
+  startSpent: exploreStart,
+  endSpent: budget.spent(),
+  attempted: exploreAttempted,
+  missing: exploreMissing,
+});
+
+phase("Deliver");
+const deliverStart = budget.spent();
+const delivered = [];
+const deliverMissing = [];
+for (const item of explored) {
+  const result = await agent(`Turn this exploration into a deliverable: ${JSON.stringify(item.result)}`, {
+    label: `deliver:${item.index}:${item.id}`,
+    schema: resultSchema,
+  });
+  if (result === null) deliverMissing.push(item.id);
+  else delivered.push({ id: item.id, result });
+}
+phases.push({
+  title: "Deliver",
+  startSpent: deliverStart,
+  endSpent: budget.spent(),
+  attempted: explored.map((item) => item.id),
+  missing: deliverMissing,
+});
+
+// INVARIANT: phase and total budgets are soft pre-call gates; completed in-flight work may overshoot a limit.
+return {
+  phases,
+  delivered,
+  totalSpent: budget.spent(),
+  remaining: budget.remaining(),
+  complete: exploreMissing.length === 0 && deliverMissing.length === 0,
+};

package/skills/workflow-authoring/examples/saved-nested-workflows.js

@@ -0,0 +1,44 @@
+export const meta = {
+  name: "saved_nested_workflows",
+  description: "Run bounded jobs sequentially through one context-supplied installed workflow",
+  phases: [{ title: "Prepare" }, { title: "Run saved workflow" }],
+};
+
+// ADAPT: accept only a saved workflow name supplied in context; never guess an installed name.
+const savedWorkflowName = args && typeof args.savedWorkflowName === "string" ? args.savedWorkflowName : null;
+if (!savedWorkflowName) throw new Error("args.savedWorkflowName must be supplied by context");
+const jobs = args && Array.isArray(args.jobs) ? args.jobs.slice(0, 8) : [{ id: "sample" }];
+const preparationSchema = {
+  type: "object",
+  properties: { ready: { type: "boolean" } },
+  required: ["ready"],
+};
+
+phase("Prepare");
+const preparation = await agent(`Check ${jobs.length} bounded nested jobs for readiness.`, {
+  label: "prepare-nested-jobs",
+  schema: preparationSchema,
+});
+const preparationMissing = preparation === null;
+
+phase("Run saved workflow");
+const nested = [];
+if (preparationMissing || !preparation.ready) {
+  for (const job of jobs) nested.push({ id: String(job.id), status: "missing", result: null });
+}
+for (const job of preparationMissing || !preparation.ready ? [] : jobs) {
+  const id = String(job.id);
+  // INVARIANT: await each nested run before starting the next; workflow() permits only one nested level.
+  const result = await workflow(savedWorkflowName, job);
+  const missing = result === null || (typeof result === "object" && result !== null && result.result === null);
+  nested.push({ id, status: missing ? "missing" : "complete", result });
+}
+const missing = nested.filter((entry) => entry.status === "missing").map((entry) => entry.id);
+
+// INVARIANT: nested runs share parent agent/concurrency/token limits, accounting, and store state.
+return {
+  preparation: { status: preparationMissing ? "missing" : "complete", result: preparation },
+  nested,
+  missing,
+  complete: !preparationMissing && missing.length === 0,
+};

package/skills/workflow-authoring/examples/structured-output.js

@@ -0,0 +1,37 @@
+export const meta = {
+  name: "structured_output",
+  description: "Validate agent output with a plain JSON Schema before JavaScript consumes fields",
+  phases: [{ title: "Extract" }],
+};
+
+// ADAPT: validate and bound work, then keep the schema as small as downstream JavaScript needs.
+const work = args && Array.isArray(args.work) ? args.work.slice(0, 8) : [{ id: "sample" }];
+const outputSchema = {
+  type: "object",
+  properties: {
+    summary: { type: "string" },
+    confidence: { type: "number", minimum: 0, maximum: 1 },
+  },
+  required: ["summary", "confidence"],
+};
+const outputs = [];
+const missing = [];
+
+phase("Extract");
+for (let index = 0; index < work.length; index++) {
+  const item = work[index];
+  const id = String(item.id);
+  const result = await agent(`Summarize this item: ${JSON.stringify(item)}`, {
+    label: `structured:${index}:${id}`,
+    schema: outputSchema,
+  });
+  if (result === null) {
+    missing.push(id);
+    outputs.push({ id, status: "missing", summary: null });
+    continue;
+  }
+  // INVARIANT: field access happens only after schema validation guarantees this shape.
+  outputs.push({ id, status: "complete", summary: result.summary.toUpperCase(), confidence: result.confidence });
+}
+
+return { outputs, missing, complete: missing.length === 0 };

package/skills/workflow-authoring/examples/tournament.js

@@ -0,0 +1,81 @@
+export const meta = {
+  name: "pairwise_tournament",
+  description: "Create bounded contenders and choose among them through pairwise judgments",
+  phases: [{ title: "Compete" }, { title: "Judge" }],
+};
+
+// ADAPT: choose the task, pairwise rubric, schemas, and a suitable contender bound.
+const task = args && typeof args.task === "string" ? args.task : "Propose a candidate";
+const rubric = args && typeof args.rubric === "string" ? args.rubric : "Prefer the better task fit";
+const contenderCount = args && Number.isInteger(args.contenders)
+  ? Math.max(2, Math.min(args.contenders, 8))
+  : 4;
+const contenderSchema = {
+  type: "object",
+  properties: { candidate: { type: "string" }, rationale: { type: "string" } },
+  required: ["candidate", "rationale"],
+};
+const judgeSchema = {
+  type: "object",
+  properties: { winnerIndex: { type: "integer", enum: [0, 1] }, reason: { type: "string" } },
+  required: ["winnerIndex", "reason"],
+};
+
+phase("Compete");
+const attempts = await parallel(
+  Array.from({ length: contenderCount }, (_, index) => () =>
+    agent(`${task}\nAttempt a distinct approach as contender ${index + 1}.`, {
+      label: `contender:${index + 1}`,
+      schema: contenderSchema,
+    }),
+  ),
+);
+const failedContenders = attempts.flatMap((attempt, index) => (attempt === null ? [index + 1] : []));
+let round = attempts.flatMap((attempt, index) =>
+  attempt === null ? [] : [{ id: `contender-${index + 1}`, attempt }],
+);
+const failedMatches = [];
+const bracket = [];
+
+phase("Judge");
+// INVARIANT: JavaScript owns the bounded bracket; agents only judge one pair at a time.
+let roundNumber = 1;
+while (round.length > 1) {
+  const matches = [];
+  for (let index = 0; index < round.length; index += 2) {
+    const match = { left: round[index], right: round[index + 1] ?? null, match: index / 2 + 1 };
+    matches.push(match);
+    bracket.push({
+      round: roundNumber,
+      match: match.match,
+      leftId: match.left.id,
+      rightId: match.right?.id ?? null,
+    });
+  }
+  const judgments = await parallel(
+    matches.map(({ left, right, match }) => () =>
+      right === null
+        ? Promise.resolve({ winnerIndex: 0, reason: "bye" })
+        : agent(
+            `Choose index 0 or 1 under this rubric: ${rubric}\nCandidate 0: ${JSON.stringify(left.attempt)}\nCandidate 1: ${JSON.stringify(right.attempt)}`,
+            { label: `judge:${roundNumber}:${match}`, schema: judgeSchema },
+          ),
+    ),
+  );
+  round = matches.flatMap(({ left, right, match }, index) => {
+    const judgment = judgments[index];
+    if (judgment === null) {
+      failedMatches.push(`round-${roundNumber}-match-${match}`);
+      return [];
+    }
+    return [judgment.winnerIndex === 1 && right !== null ? right : left];
+  });
+  roundNumber++;
+}
+
+return {
+  winner: failedMatches.length === 0 ? (round[0] ?? null) : null,
+  bracket,
+  failed: { contenders: failedContenders, matches: failedMatches },
+  complete: failedContenders.length === 0 && failedMatches.length === 0 && round.length === 1,
+};

package/skills/workflow-authoring/examples/validated-gate.js

@@ -0,0 +1,63 @@
+export const meta = {
+  name: "validated_gate",
+  description: "Use validator feedback to steer bounded structured attempts through gate()",
+  phases: [{ title: "Validate" }],
+};
+
+// ADAPT: replace the task, structured fields, and task-owned acceptance policy.
+const task = args && typeof args.task === "string" ? args.task : "Produce an acceptable answer.";
+const maxAttempts =
+  args && Number.isInteger(args.maxAttempts) ? Math.max(1, Math.min(args.maxAttempts, 5)) : 3;
+const resultSchema = {
+  type: "object",
+  properties: {
+    acceptable: { type: "boolean" },
+    answer: { type: "string" },
+    feedback: { type: "string" },
+  },
+  required: ["acceptable", "answer", "feedback"],
+};
+const ledger = [];
+
+phase("Validate");
+const outcome = await gate(
+  async (feedback, attempt) => {
+    // gate() supplies undefined feedback initially and a zero-based attempt index.
+    const value = await agent(
+      `${task}${feedback ? ` Address this validator feedback: ${feedback}` : ""}`,
+      {
+        label: `gate-attempt:${attempt + 1}`,
+        schema: resultSchema,
+      },
+    );
+    ledger.push({
+      attempt: attempt + 1,
+      feedbackReceived: feedback ?? null,
+      accepted: false,
+      validatorFeedback: null,
+      value,
+    });
+    return value;
+  },
+  (value) => {
+    // The validator must return an object. A bare boolean is never an accepting verdict.
+    const ok = value !== null && value.acceptable === true && value.answer.trim().length > 0;
+    const feedback =
+      value === null
+        ? "The previous attempt returned no usable result."
+        : value.feedback.trim() || "The answer did not satisfy the acceptance policy.";
+    const entry = ledger[ledger.length - 1];
+    entry.accepted = ok;
+    entry.validatorFeedback = ok ? null : feedback;
+    return ok ? { ok: true } : { ok: false, feedback };
+  },
+  { attempts: maxAttempts },
+);
+
+// INVARIANT: return gate exhaustion explicitly together with every attempt and feedback handoff.
+return {
+  ok: outcome.ok,
+  value: outcome.value,
+  attempts: outcome.attempts,
+  ledger,
+};

package/skills/workflow-authoring/references/capabilities.md

@@ -0,0 +1,41 @@
+<!-- GENERATED from WORKFLOW_CAPABILITY_CONTRACT; do not edit by hand. -->
+# Workflow capability index
+
+Contract format: `1.0.0`<br>
+Contract content / skill / extension: `3.3.0`
+
+This compact generated index covers supported runtime globals and workflow-tool inputs. For constraints, compatibility behavior, internal boundaries, and dynamic-reference ownership, follow the [exhaustive generated facts](capability-details.md).
+
+## Supported capability index
+
+<!-- BEGIN GENERATED SUPPORTED WORKFLOW CAPABILITIES -->
+| Name | Classification | Signature | Options and defaults |
+| --- | --- | --- | --- |
+| agent | runtime-global | `agent(prompt, options?) => Promise<string \| structured value \| null>` | `label`: string (optional; default: derived from phase and call count)<br>`phase`: string (optional; default: current phase)<br>`schema`: plain JSON Schema (optional)<br>`model`: string (optional)<br>`tier`: string (optional)<br>`isolation`: "worktree" (optional)<br>`agentType`: string (optional)<br>`timeoutMs`: number \| null (optional; default: run timeout; null disables)<br>`retries`: number (optional; default: run retry count) |
+| parallel | runtime-global | `parallel(thunks) => Promise<Array<unknown \| null>>` | — |
+| pipeline | runtime-global | `pipeline(items, ...stages) => Promise<Array<unknown \| null>>` | — |
+| workflow | runtime-global | `workflow(savedName, childArgs?) => Promise<unknown>` | — |
+| verify | runtime-global | `verify(item: unknown, options?: { reviewers?: number; threshold?: number; lens?: string \| string[] }) => Promise<{ real: boolean; realCount: number; total: number; votes: Array<{ real: boolean; reason?: string }> }>` | `reviewers`: number (optional; default: 2)<br>`threshold`: number (optional; default: 0.5)<br>`lens`: string \| string[] (optional) |
+| judgePanel | runtime-global | `judgePanel(attempts: unknown[], options?: { judges?: number; rubric?: string }) => Promise<{ index: number; attempt: unknown; score: number; judgments: Array<{ score: number; reason?: string }> } \| undefined>` | `judges`: number (optional; default: 3)<br>`rubric`: string (optional; default: "overall quality and correctness") |
+| loopUntilDry | runtime-global | `loopUntilDry(options: { round: (roundIndex: number) => unknown[] \| Promise<unknown[]>; key?: (item: unknown) => string; consecutiveEmpty?: number; maxRounds?: number }) => Promise<unknown[]>` | `round`: (roundIndex: number) => unknown[] \| Promise<unknown[]> (required)<br>`key`: (item: unknown) => string (optional; default: JSON.stringify)<br>`consecutiveEmpty`: number (optional; default: 2)<br>`maxRounds`: number (optional; default: 50) |
+| completenessCheck | runtime-global | `completenessCheck(taskArgs: unknown, results: unknown) => Promise<{ complete: boolean; missing?: string[] } \| null>` | — |
+| retry | runtime-global | `retry(thunk: (attempt: number) => unknown \| Promise<unknown>, options?: { attempts?: number; until?: (result: unknown) => boolean }) => Promise<unknown>` | `attempts`: number (optional; default: 3)<br>`until`: (result: unknown) => boolean (optional; default: accept first result when omitted) |
+| gate | runtime-global | `gate(thunk: (feedback: string \| undefined, attempt: number) => unknown \| Promise<unknown>, validator: (value: unknown) => { ok: boolean; feedback?: string } \| Promise<{ ok: boolean; feedback?: string }>, options?: { attempts?: number }) => Promise<{ ok: boolean; value: unknown; attempts: number }>` | `attempts`: number (optional; default: 3) |
+| checkpoint | runtime-global | `checkpoint(prompt, options?) => Promise<unknown>` | `default`: unknown (optional; default: true when no UI and omitted)<br>`headless`: "default" \| "abort" (optional; default: "default")<br>`kind`: "confirm" \| "input" \| "select" (optional; default: "confirm")<br>`choices`: string[] (optional)<br>`timeoutMs`: number (optional) |
+| log | runtime-global | `log(message) => void` | — |
+| phase | runtime-global | `phase(title, options?) => void` | `budget`: number (optional) |
+| args | runtime-global | `args: unknown` | — |
+| cwd | runtime-global | `cwd: string` | — |
+| process | runtime-global | `process: { cwd(): string }` | — |
+| budget | runtime-global | `budget: { total, spent(), remaining() }` | — |
+| script | workflow-tool-input | `script?: string` | — |
+| name | workflow-tool-input | `name?: string` | — |
+| args | workflow-tool-input | `args?: unknown` | — |
+| background | workflow-tool-input | `background?: boolean = true` | — |
+| maxAgents | workflow-tool-input | `maxAgents?: number = 1000` | — |
+| concurrency | workflow-tool-input | `concurrency?: number` | — |
+| agentRetries | workflow-tool-input | `agentRetries?: number = configured value or 0` | — |
+| agentTimeoutMs | workflow-tool-input | `agentTimeoutMs?: number = configured default or unbounded` | — |
+| tokenBudget | workflow-tool-input | `tokenBudget?: number = configured default or unlimited` | — |
+| resumeFromRunId | workflow-tool-input | `resumeFromRunId?: string` | — |
+<!-- END GENERATED SUPPORTED WORKFLOW CAPABILITIES -->