@yycholla/pi-dynamic-workflows 3.3.0

package/dist/usage-limit-scheduler.js

@@ -0,0 +1,368 @@
+/**
+ * Auto-resume for runs paused on a provider usage limit.
+ *
+ * A workflow run pauses (does not fail) when a provider quota/usage limit is hit
+ * (see errors.ts PROVIDER_USAGE_LIMIT, workflow-manager.ts executeRun()'s catch
+ * block). Left alone, the run just sits there until a human runs /workflows and
+ * hits resume. This module watches the manager's public event stream and, for
+ * runs that are auto-resume-eligible, arms a timer to call manager.resume() once
+ * the provider's quota is likely to have refilled — with exponential backoff if
+ * it keeps hitting the wall, and a hard attempt cap so it never retries forever.
+ *
+ * Deliberately standalone: it consumes ONLY WorkflowManager's public surface
+ * (on/off, listAllRuns, resume, getPersistence) so it stays decoupled from
+ * manager/persistence internals. It owns its own timers and its own bookkeeping
+ * (in-memory, best-effort persisted) — it does not rely on manager.stop(), which
+ * only operates on in-memory runs.
+ */
+const DEFAULT_MAX_ATTEMPTS = 5;
+const DEFAULT_MIN_DELAY_MS = 60_000;
+const DEFAULT_FALLBACK_DELAY_MS = 300_000;
+const DEFAULT_MAX_DELAY_MS = 6 * 60 * 60 * 1000;
+/**
+ * Best-effort parse of a provider's human reset hint ("Resets in ~3h",
+ * "resets in 5m", "in 90s", "1h30m") into milliseconds. Sums every
+ * (number, unit) pair found, so combined forms like "1h30m" work for free.
+ * Returns undefined when nothing recognizable is found — callers should fall
+ * back to a fixed delay rather than guess.
+ */
+export function parseResetHintMs(hint) {
+    if (!hint)
+        return undefined;
+    // No trailing \b: combined forms like "1h30m" have a digit right after the
+    // unit letter, which is itself a word character, so \b would never match
+    // there. A negative lookahead for another letter is the correct boundary —
+    // it still stops "hours" from partially matching as bare "h" mid-word while
+    // allowing a unit to be followed immediately by the next (digit, unit) pair.
+    const re = /(\d+(?:\.\d+)?)\s*(hours?|hrs?|h|minutes?|mins?|m|seconds?|secs?|s)(?![a-z])/gi;
+    let match;
+    let totalMs = 0;
+    let found = false;
+    // biome-ignore lint/suspicious/noAssignInExpressions: standard regex-exec loop
+    while ((match = re.exec(hint)) !== null) {
+        const value = Number.parseFloat(match[1]);
+        if (!Number.isFinite(value))
+            continue;
+        const unit = match[2].toLowerCase();
+        found = true;
+        if (unit.startsWith("h"))
+            totalMs += value * 3_600_000;
+        else if (unit.startsWith("m"))
+            totalMs += value * 60_000;
+        else if (unit.startsWith("s"))
+            totalMs += value * 1_000;
+    }
+    return found ? totalMs : undefined;
+}
+/**
+ * delay = clamp(minDelayMs, remaining * 2^(attempts-1), maxDelayMs), where
+ * remaining = parsed(resetHint) ?? fallbackDelayMs, minus time already elapsed.
+ * The exponent is capped defensively so a pathological attempt count can't
+ * overflow the multiplication to Infinity/NaN before the maxDelayMs clamp runs.
+ */
+export function computeAutoResumeDelayMs(params) {
+    const base = parseResetHintMs(params.resetHint) ?? params.fallbackDelayMs;
+    const remaining = base - params.elapsedMs;
+    const exponent = Math.min(Math.max(params.attempts - 1, 0), 30);
+    const backoff = remaining * 2 ** exponent;
+    return Math.min(params.maxDelayMs, Math.max(params.minDelayMs, backoff));
+}
+/**
+ * Watches a WorkflowManager for usage-limit pauses and auto-resumes eligible
+ * runs once the provider's quota is likely to have refilled.
+ *
+ * Event-driven "fire and watch": an attempt is consumed when a run ENTERS a
+ * usage_limit pause (live via the "paused" event, or once at cold start for a
+ * run that was already paused), never when a resume is merely fired. When an
+ * armed timer fires, resume() is called; if it returns false (lease busy, run
+ * already gone, etc.) no attempt is consumed and a short un-backed-off retry is
+ * armed instead, unless the run has reached a terminal state on disk. If resume()
+ * returns true, this scheduler steps back — the existing "paused" subscription
+ * re-arms with backoff if the run hits the wall again, and "complete"/"error"/
+ * "stopped" clean up its timer.
+ */
+export class UsageLimitScheduler {
+    manager;
+    now;
+    setTimer;
+    clearTimer;
+    maxAttempts;
+    minDelayMs;
+    fallbackDelayMs;
+    maxDelayMs;
+    diagnostic;
+    state = new Map();
+    disposed = false;
+    /**
+     * Runs this scheduler is currently auto-resuming (its own timer fired). Used to
+     * tell an auto-resume's "resumed" event apart from a manual one: an auto-resume
+     * must keep the backoff counter (it IS the backoff), a manual resume resets it.
+     */
+    autoResumingRunIds = new Set();
+    onPaused = (event) => {
+        this.safe(() => this.handlePaused(event));
+    };
+    onTerminal = (event) => {
+        this.safe(() => this.cleanup(event?.runId));
+    };
+    onResumed = (event) => {
+        this.safe(() => this.handleResumed(event));
+    };
+    constructor(manager, options = {}) {
+        this.manager = manager;
+        this.now = options.now ?? Date.now;
+        this.setTimer = options.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+        this.clearTimer = options.clearTimer ?? ((handle) => clearTimeout(handle));
+        this.maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+        this.minDelayMs = options.minDelayMs ?? DEFAULT_MIN_DELAY_MS;
+        this.fallbackDelayMs = options.fallbackDelayMs ?? DEFAULT_FALLBACK_DELAY_MS;
+        this.maxDelayMs = options.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+        this.diagnostic =
+            options.onDiagnostic ??
+                ((message, detail) => {
+                    console.warn(message, detail ?? "");
+                });
+        this.manager.on("paused", this.onPaused);
+        this.manager.on("resumed", this.onResumed);
+        this.manager.on("complete", this.onTerminal);
+        this.manager.on("error", this.onTerminal);
+        this.manager.on("stopped", this.onTerminal);
+        // Cold-start re-arm: pick up any run that was already paused-on-usage_limit
+        // before this process (and thus this scheduler instance) existed.
+        this.safe(() => this.coldStartRearm());
+    }
+    /** Clear every armed timer and unsubscribe from the manager. Idempotent. */
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.manager.off("paused", this.onPaused);
+        this.manager.off("resumed", this.onResumed);
+        this.manager.off("complete", this.onTerminal);
+        this.manager.off("error", this.onTerminal);
+        this.manager.off("stopped", this.onTerminal);
+        for (const entry of this.state.values()) {
+            if (entry.timer !== undefined)
+                this.clearTimer(entry.timer);
+        }
+        this.state.clear();
+    }
+    /** Test/diagnostic helper: in-memory attempt count tracked for a run, if any. */
+    getAttemptCount(runId) {
+        return this.state.get(runId)?.attempts;
+    }
+    /** Test/diagnostic helper: whether a resume timer is currently armed for a run. */
+    hasArmedTimer(runId) {
+        return this.state.get(runId)?.timer !== undefined;
+    }
+    // ---- event handlers -----------------------------------------------------
+    handlePaused(event) {
+        if (this.disposed || !event?.runId || event.reason !== "usage_limit")
+            return;
+        const runId = event.runId;
+        // The "paused" event fires BEFORE the manager's own persistRun() write for
+        // this pause (see executeRun()'s catch block: emit then persist). A disk
+        // read here can therefore be stale for fields this exact pause is about to
+        // set (status/pauseReason/resetHint) — but NOT for `autoResume`, which is
+        // fixed at run-start and persisted on every persistRun() call since, so a
+        // stale read of it is still correct. resetHint comes off the event itself,
+        // not disk, to avoid that race.
+        const persisted = this.safeLoad(runId);
+        if (persisted?.autoResume === false) {
+            this.diagnostic(`[usage-limit-scheduler] ${runId}: autoResume is disabled for this run, not arming`);
+            return;
+        }
+        const priorAttempts = this.state.get(runId)?.attempts ?? persisted?.autoResumeAttempts ?? 0;
+        this.arm(runId, {
+            attempts: priorAttempts + 1,
+            resetHint: event.resetHint ?? persisted?.resetHint,
+            elapsedMs: 0,
+        });
+    }
+    cleanup(runId) {
+        if (!runId)
+            return;
+        const entry = this.state.get(runId);
+        if (entry?.timer !== undefined)
+            this.clearTimer(entry.timer);
+        this.state.delete(runId);
+    }
+    /**
+     * A run was resumed. If WE resumed it (auto-resume timer fired), leave the
+     * backoff counter alone — that's the sequence doing its job, and it must still
+     * be able to reach the cap. If a human resumed it (via /workflows), treat that
+     * as a deliberate fresh start: drop the in-memory given-up state and reset the
+     * persisted counter so a later pause re-enters the normal backoff from attempt 1
+     * instead of staying silently given-up forever.
+     */
+    handleResumed(event) {
+        if (this.disposed || !event?.runId)
+            return;
+        if (this.autoResumingRunIds.has(event.runId))
+            return;
+        this.cleanup(event.runId);
+        this.persistAttempts(event.runId, 0);
+    }
+    coldStartRearm() {
+        const runs = this.manager.listAllRuns();
+        for (const run of runs) {
+            if (run.status !== "paused" || run.pauseReason !== "usage_limit")
+                continue;
+            if (run.autoResume === false)
+                continue;
+            if (this.state.has(run.runId))
+                continue;
+            const priorAttempts = run.autoResumeAttempts ?? 0;
+            const updatedAtMs = Date.parse(run.updatedAt);
+            const elapsedMs = Number.isFinite(updatedAtMs) ? Math.max(0, this.now() - updatedAtMs) : 0;
+            this.arm(run.runId, {
+                attempts: priorAttempts + 1,
+                resetHint: run.resetHint,
+                elapsedMs,
+            });
+        }
+    }
+    // ---- arming / firing ------------------------------------------------------
+    arm(runId, params) {
+        const existing = this.state.get(runId);
+        if (existing?.timer !== undefined)
+            this.clearTimer(existing.timer);
+        if (params.attempts > this.maxAttempts) {
+            const alreadyLogged = existing?.gaveUp === true;
+            // Freeze the counter at a single sentinel (maxAttempts + 1) instead of
+            // storing the raw overflow. coldStartRearm() reads the persisted count and
+            // adds 1 on every restart; without this clamp a given-up run's counter
+            // grew without bound (…6, 7, 8… → "giving up after 23") across cold starts
+            // (#106). Clamping makes the persisted value idempotent — a rearm of an
+            // already-given-up run rewrites the same 6.
+            const frozen = this.maxAttempts + 1;
+            this.state.set(runId, { attempts: frozen, gaveUp: true });
+            this.persistAttempts(runId, frozen);
+            // Log the give-up exactly once per crossing. In-process the gaveUp flag
+            // guards it; across restarts a fresh scheduler has no memory, so also
+            // suppress when this arm is merely re-giving-up an already-capped run
+            // (params.attempts already past the sentinel, i.e. prior was ≥ frozen).
+            if (!alreadyLogged && params.attempts <= frozen) {
+                this.diagnostic(`[usage-limit-scheduler] ${runId}: giving up after ${this.maxAttempts} auto-resume attempt(s) ` +
+                    `(max ${this.maxAttempts}); leaving paused for manual resume`);
+            }
+            return;
+        }
+        const delay = computeAutoResumeDelayMs({
+            resetHint: params.resetHint,
+            attempts: params.attempts,
+            elapsedMs: params.elapsedMs,
+            minDelayMs: this.minDelayMs,
+            fallbackDelayMs: this.fallbackDelayMs,
+            maxDelayMs: this.maxDelayMs,
+        });
+        const timer = this.setTimer(() => this.safe(() => this.onTimerFire(runId)), delay);
+        this.state.set(runId, { attempts: params.attempts, timer });
+        this.persistAttempts(runId, params.attempts);
+    }
+    async onTimerFire(runId) {
+        if (this.disposed)
+            return;
+        const entry = this.state.get(runId);
+        if (!entry || entry.gaveUp)
+            return;
+        // The timer that just fired is spent; clear its handle while we await.
+        this.state.set(runId, { ...entry, timer: undefined });
+        let resumed = false;
+        // Mark this as OUR resume so handleResumed() (fired synchronously inside
+        // resume(), before it returns) doesn't mistake it for a manual resume and
+        // reset the backoff counter mid-sequence.
+        this.autoResumingRunIds.add(runId);
+        try {
+            resumed = await this.manager.resume(runId);
+        }
+        catch (err) {
+            this.diagnostic(`[usage-limit-scheduler] ${runId}: resume() threw`, err);
+            resumed = false;
+        }
+        finally {
+            this.autoResumingRunIds.delete(runId);
+        }
+        if (this.disposed)
+            return;
+        if (resumed) {
+            // Don't consume/advance anything further here — the existing "paused"
+            // subscription re-arms (with backoff) if this run hits the wall again,
+            // and "complete"/"error"/"stopped" clean up on any terminal outcome.
+            return;
+        }
+        // resume() returned false without throwing: it refused for a structural
+        // reason (already running/aborted, no persisted script, or the lease is
+        // held elsewhere) rather than a real failed attempt. Per the fix for bug
+        // (a), that must NOT consume an attempt. Distinguish "gone for good" from
+        // "try again shortly":
+        const status = this.safeStatus(runId);
+        if (status === undefined || status === "completed" || status === "aborted") {
+            this.cleanup(runId);
+            return;
+        }
+        const current = this.state.get(runId) ?? entry;
+        const timer = this.setTimer(() => this.safe(() => this.onTimerFire(runId)), this.minDelayMs);
+        this.state.set(runId, { attempts: current.attempts, timer });
+    }
+    // ---- helpers --------------------------------------------------------------
+    safeLoad(runId) {
+        try {
+            return this.manager.getPersistence().load(runId) ?? undefined;
+        }
+        catch (err) {
+            this.diagnostic(`[usage-limit-scheduler] ${runId}: persistence load failed`, err);
+            return undefined;
+        }
+    }
+    safeStatus(runId) {
+        try {
+            return this.manager.listAllRuns().find((r) => r.runId === runId)?.status;
+        }
+        catch (err) {
+            this.diagnostic(`[usage-limit-scheduler] ${runId}: listAllRuns() failed`, err);
+            return undefined;
+        }
+    }
+    /**
+     * Best-effort persist of the in-memory attempt counter, so a cold start after
+     * a crash can approximately resume the backoff sequence instead of restarting
+     * it. Deferred to a microtask so it lands AFTER the manager's own persistRun()
+     * write for this same pause (which happens synchronously, right after the
+     * "paused" event we're reacting to returns control to executeRun()) — writing
+     * synchronously here would just get clobbered, since persistRun() writes a
+     * fresh PersistedRunState object literal that doesn't know about this field.
+     * This is still inherently racy across process crashes (see class docs); it
+     * is a best-effort durability aid, not a correctness requirement for the live
+     * (in-memory) path.
+     */
+    persistAttempts(runId, attempts) {
+        queueMicrotask(() => {
+            if (this.disposed)
+                return;
+            try {
+                const persistence = this.manager.getPersistence();
+                const current = persistence.load(runId);
+                if (!current)
+                    return;
+                persistence.save({ ...current, autoResumeAttempts: attempts });
+            }
+            catch (err) {
+                this.diagnostic(`[usage-limit-scheduler] ${runId}: failed to persist autoResumeAttempts`, err);
+            }
+        });
+    }
+    safe(fn) {
+        try {
+            const result = fn();
+            if (result && typeof result.catch === "function") {
+                result.catch((err) => {
+                    this.diagnostic("[usage-limit-scheduler] async handler error", err);
+                });
+            }
+        }
+        catch (err) {
+            this.diagnostic("[usage-limit-scheduler] handler error", err);
+        }
+    }
+}

package/dist/web-tools.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Real web tools for research workflows. These execute in the extension host
+ * process (which has network access), not in a subagent sandbox, so they perform
+ * genuine HTTP requests via Node's fetch.
+ *
+ * - web_search: best-effort Bing HTML scrape -> result {url, title}
+ * - web_fetch:  fetch a URL and return readable text (HTML stripped, truncated)
+ */
+import { type ToolDefinition } from "@earendil-works/pi-coding-agent";
+export declare function htmlToText(html: string): string;
+export declare function parseBingResults(html: string, limit: number): Array<{
+    url: string;
+    title: string;
+}>;
+/** A tool that searches the web (best-effort) and returns result URLs + titles. */
+export declare function createWebSearchTool(): ToolDefinition;
+/** A tool that fetches a URL and returns readable text. */
+export declare function createWebFetchTool(maxChars?: number): ToolDefinition;
+/** Both web tools, for injecting into a research workflow's agents. */
+export declare function createWebTools(): ToolDefinition[];

package/dist/web-tools.js

@@ -0,0 +1,120 @@
+/**
+ * Real web tools for research workflows. These execute in the extension host
+ * process (which has network access), not in a subagent sandbox, so they perform
+ * genuine HTTP requests via Node's fetch.
+ *
+ * - web_search: best-effort Bing HTML scrape -> result {url, title}
+ * - web_fetch:  fetch a URL and return readable text (HTML stripped, truncated)
+ */
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+const UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120 Safari/537.36";
+async function fetchText(url, timeoutMs = 15000) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(url, { headers: { "user-agent": UA }, signal: controller.signal, redirect: "follow" });
+        return { status: res.status, body: await res.text() };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function htmlToText(html) {
+    return html
+        .replace(/<script[\s\S]*?<\/script>/gi, " ")
+        .replace(/<style[\s\S]*?<\/style>/gi, " ")
+        .replace(/<\/(p|div|li|h[1-6]|tr|br)>/gi, "\n")
+        .replace(/<[^>]+>/g, " ")
+        .replace(/&nbsp;/g, " ")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&#39;|&apos;/g, "'")
+        .replace(/&quot;/g, '"')
+        .replace(/[ \t]+/g, " ")
+        .replace(/\n +/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+export function parseBingResults(html, limit) {
+    const out = [];
+    const seen = new Set();
+    for (const m of html.matchAll(/<h2[^>]*>\s*<a[^>]+href="(https?:\/\/[^"]+)"[^>]*>([\s\S]*?)<\/a>/g)) {
+        const url = m[1];
+        if (/\.bing\.com|go\.microsoft\.com/.test(url) || seen.has(url))
+            continue;
+        seen.add(url);
+        out.push({ url, title: m[2].replace(/<[^>]+>/g, "").trim() });
+        if (out.length >= limit)
+            break;
+    }
+    return out;
+}
+/** A tool that searches the web (best-effort) and returns result URLs + titles. */
+export function createWebSearchTool() {
+    return defineTool({
+        name: "web_search",
+        label: "Web Search",
+        description: "Search the web and return a list of result URLs and titles. Use before web_fetch to find sources.",
+        promptSnippet: "Search the web for sources",
+        parameters: Type.Object({
+            query: Type.String({ description: "The search query." }),
+            count: Type.Optional(Type.Number({ description: "Max results (default 6)." })),
+        }),
+        async execute(_id, params) {
+            const limit = Math.min(Math.max(params.count ?? 6, 1), 10);
+            try {
+                const { status, body } = await fetchText(`https://www.bing.com/search?q=${encodeURIComponent(params.query)}`);
+                const results = parseBingResults(body, limit);
+                const text = results.length
+                    ? results.map((r, i) => `${i + 1}. ${r.title}\n   ${r.url}`).join("\n")
+                    : `No results parsed (HTTP ${status}). Try a different query or fetch a known URL directly.`;
+                return { content: [{ type: "text", text }], details: { results } };
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: `web_search failed: ${error instanceof Error ? error.message : error}` }],
+                    details: { results: [] },
+                };
+            }
+        },
+    });
+}
+/** A tool that fetches a URL and returns readable text. */
+export function createWebFetchTool(maxChars = 6000) {
+    return defineTool({
+        name: "web_fetch",
+        label: "Web Fetch",
+        description: "Fetch a URL and return its readable text content (HTML stripped, truncated).",
+        promptSnippet: "Fetch a URL's text",
+        parameters: Type.Object({
+            url: Type.String({ description: "The absolute URL to fetch." }),
+        }),
+        async execute(_id, params) {
+            try {
+                const { status, body } = await fetchText(params.url);
+                const text = htmlToText(body).slice(0, maxChars);
+                return {
+                    content: [{ type: "text", text: `HTTP ${status} ${params.url}\n\n${text}` }],
+                    details: { status, url: params.url },
+                };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `web_fetch failed for ${params.url}: ${error instanceof Error ? error.message : error}`,
+                        },
+                    ],
+                    details: { status: 0, url: params.url },
+                };
+            }
+        },
+    });
+}
+/** Both web tools, for injecting into a research workflow's agents. */
+export function createWebTools() {
+    return [createWebSearchTool(), createWebFetchTool()];
+}

package/dist/workflow-authoring-coverage.d.ts

@@ -0,0 +1,70 @@
+import { WorkflowAuthoringProtection } from "./enums.js";
+/** Exact installed guidance location retained for an authoring surface without model evidence. */
+export interface ProtectedGuidanceSurface {
+    path: string;
+    anchor?: string;
+    requiredText?: string;
+}
+/** Evidence and optimization policy for one stable workflow authoring surface. */
+export interface WorkflowAuthoringCoverageEntry {
+    id: string;
+    kind: string;
+    reference: {
+        path: string;
+        anchor?: string;
+    };
+    example?: string;
+    behaviorEvidence: readonly string[];
+    comprehensionScenarios: readonly string[];
+    protection: WorkflowAuthoringProtection;
+    protectedGuidance: readonly ProtectedGuidanceSurface[];
+}
+/** Scenario identifiers that release checks may accept as provider-backed evidence. */
+export declare const WORKFLOW_COMPREHENSION_SCENARIO_IDS: string[];
+/** Mixed guidance files that require explicit acceptance while behavioral coverage remains partial. */
+export declare const WORKFLOW_AUTHORING_FROZEN_FILES: readonly [{
+    readonly path: "skills/workflow-authoring/SKILL.md";
+    readonly sha256: "d2843c4d928b6f622271c65bf4cf5d54cb219efca0ce92d8c5f4d8204365bf91";
+}, {
+    readonly path: "skills/workflow-authoring/references/runtime.md";
+    readonly sha256: "14f1c4496c523d2e37316a7c96041a22630a65d342d08fdd77aeca2d325e22a3";
+}, {
+    readonly path: "skills/workflow-authoring/references/helpers.md";
+    readonly sha256: "1c8d253649f00412511f17ffc08c6156797b99de72ae037e14f2ea92ac33a11e";
+}, {
+    readonly path: "skills/workflow-authoring/references/specialized-helpers.md";
+    readonly sha256: "7597c94bbacea885697fb2d05a96ed9ec39403ca6d3a94547bf8ce5e233b2c76";
+}, {
+    readonly path: "skills/workflow-authoring/references/lifecycle.md";
+    readonly sha256: "e2f187a7b633beef0ca257e6782f72a140fc06b37a58aac423432d36d1dc19ee";
+}, {
+    readonly path: "skills/workflow-authoring/references/pattern-selection.md";
+    readonly sha256: "923988a1b4d506a7b330bf5e4b8ab47cf8456edcfe6674b5d8d8848264633c3d";
+}, {
+    readonly path: "skills/workflow-authoring/references/focused-recipes.md";
+    readonly sha256: "30906054232f67029e31f71b3b093f9949f6de9116e4381f433009c401f2c5c7";
+}, {
+    readonly path: "skills/workflow-authoring/references/registry-ownership.md";
+    readonly sha256: "daf324448be16732c6796fd6359d1b1b842fa550ed616a6154f556d6ec1ef0b9";
+}, {
+    readonly path: "skills/workflow-authoring/references/review.md";
+    readonly sha256: "2bd97acb87a8f6e9514892cdf5c431305b3d8952ba9761c1c203c217b08c9e7d";
+}, {
+    readonly path: "skills/workflow-authoring/references/debugging.md";
+    readonly sha256: "2938e635f5856f2934e42c9cc3b7035a66d53176f4ab2beadfeabb9abf42e6cc";
+}, {
+    readonly path: "skills/workflow-authoring/examples/classify-and-act.js";
+    readonly sha256: "23d0d9f37ee8648cd29ca526b0b23cf55bd3ac57efd02e1b93e227bcd0c18603";
+}, {
+    readonly path: "skills/workflow-authoring/examples/tournament.js";
+    readonly sha256: "3a90bd3055c5e38e13fd8d7447173fc2e6a141fbc33b9bcc8a84723b7ab9d2e6";
+}, {
+    readonly path: "skills/workflow-authoring/examples/validated-gate.js";
+    readonly sha256: "1cb4b3941ae61ebd1e12ada899f7d04678fe858a307c7fabc408603a4b9ba889";
+}];
+/** Stable orchestration-pattern identifiers covered by the authoring inventory. */
+export declare const WORKFLOW_AUTHORING_PATTERN_IDS: readonly ["workflow.pattern.classify-and-act", "workflow.pattern.fan-out-and-synthesize", "workflow.pattern.adversarial-verification", "workflow.pattern.generate-and-filter", "workflow.pattern.tournament", "workflow.pattern.loop-until-done"];
+/** Stable focused-recipe identifiers covered by the authoring inventory. */
+export declare const WORKFLOW_AUTHORING_RECIPE_IDS: readonly ["workflow.recipe.phased-budgets", "workflow.recipe.saved-nested-workflows", "workflow.recipe.bounded-semantic-retry", "workflow.recipe.validator-feedback", "workflow.recipe.structured-output"];
+/** Complete release-gated inventory of behavioral coverage and frozen authoring guidance. */
+export declare const WORKFLOW_AUTHORING_COVERAGE: readonly WorkflowAuthoringCoverageEntry[];