taskflow-core 0.1.0

package/dist/flowir/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Public entry point for the FlowIR compile seam.
+ *
+ * `compileTaskflowToIR` is the read-only, content-addressed IR projection used
+ * by:
+ *   - `/tf ir <flow>` / `action=ir`     — render the compiled IR + hash (0 tokens)
+ *   - the runtime (`runTaskflowLayers`) — fold `ir.hash` into the cache key
+ *     (== `flowDefHash` in the stub; the overstory-canonical hash once the
+ *     genuine compiler is vendored) and persist `ir.meta.declaredDeps` to
+ *     `RunState` (M2 declared plane).
+ *
+ * The stub hash reuses the already-vendored overstory `flowDefHash` algorithm
+ * (./hash.ts) so pi-taskflow and overstory share one byte-identical hashing
+ * contract today. `usedFallbackHash` is `true` in the stub (the genuine
+ * overstory `hashIR` is not yet wired); it flips to `false` once the compiler
+ * is vendored, at which point the cache key's `v2:` prefix advances to `v3:`
+ * (see docs/internal/cache-migration.md).
+ *
+ * Pure + async (Web Crypto). Never throws — a hash failure leaves `hash`
+ * unset and `usedFallbackHash` true; the runtime degrades to the safe
+ * flowName-only cache key (cross-run disabled for that run).
+ *
+ * @see docs/internal/overstory-convergence-roadmap.md §3 (M1)
+ * @see docs/internal/rfc-flowir-compilation.md
+ */
+import type { Taskflow } from "../schema.ts";
+import type { TaskflowIR } from "./meta.ts";
+/**
+ * Compile a (desugared) `Taskflow` into its content-addressed IR.
+ *
+ * The returned `hash` is, in the stub, exactly `flowDefHash(def)` — the
+ * overstory-vendored canonical-JSON + SHA-256-truncation contract. The
+ * `usedFallbackHash` flag records that this is the *fallback* hash (non-IR-
+ * canonical): it is `true` whenever the stub cannot guarantee IR-canonicity
+ * (any phase with a `when`, or any hash-compute failure).
+ *
+ * Never throws. Returns structured diagnostics so `/tf ir` on a broken flow
+ * yields a clean error table instead of crashing.
+ */
+export declare function compileTaskflowToIR(def: Taskflow): Promise<TaskflowIR>;
+export type { CompileError, CompileWarning, DeclaredDeps, FlowIR, FlowIRNode, TaskflowIR, TaskflowIRMeta, } from "./meta.ts";
+export { phaseFingerprint } from "./phasefp.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/flowir/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/flowir/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAG7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C;;;;;;;;;;;GAWG;AACH,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC,CAmB5E;AAED,YAAY,EACX,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,MAAM,EACN,UAAU,EACV,UAAU,EACV,cAAc,GACd,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC"}

package/dist/flowir/index.js

@@ -0,0 +1,62 @@
+/**
+ * Public entry point for the FlowIR compile seam.
+ *
+ * `compileTaskflowToIR` is the read-only, content-addressed IR projection used
+ * by:
+ *   - `/tf ir <flow>` / `action=ir`     — render the compiled IR + hash (0 tokens)
+ *   - the runtime (`runTaskflowLayers`) — fold `ir.hash` into the cache key
+ *     (== `flowDefHash` in the stub; the overstory-canonical hash once the
+ *     genuine compiler is vendored) and persist `ir.meta.declaredDeps` to
+ *     `RunState` (M2 declared plane).
+ *
+ * The stub hash reuses the already-vendored overstory `flowDefHash` algorithm
+ * (./hash.ts) so pi-taskflow and overstory share one byte-identical hashing
+ * contract today. `usedFallbackHash` is `true` in the stub (the genuine
+ * overstory `hashIR` is not yet wired); it flips to `false` once the compiler
+ * is vendored, at which point the cache key's `v2:` prefix advances to `v3:`
+ * (see docs/internal/cache-migration.md).
+ *
+ * Pure + async (Web Crypto). Never throws — a hash failure leaves `hash`
+ * unset and `usedFallbackHash` true; the runtime degrades to the safe
+ * flowName-only cache key (cross-run disabled for that run).
+ *
+ * @see docs/internal/overstory-convergence-roadmap.md §3 (M1)
+ * @see docs/internal/rfc-flowir-compilation.md
+ */
+import { flowDefHash } from "./hash.js";
+import { translateTaskflow } from "./translate.js";
+/**
+ * Compile a (desugared) `Taskflow` into its content-addressed IR.
+ *
+ * The returned `hash` is, in the stub, exactly `flowDefHash(def)` — the
+ * overstory-vendored canonical-JSON + SHA-256-truncation contract. The
+ * `usedFallbackHash` flag records that this is the *fallback* hash (non-IR-
+ * canonical): it is `true` whenever the stub cannot guarantee IR-canonicity
+ * (any phase with a `when`, or any hash-compute failure).
+ *
+ * Never throws. Returns structured diagnostics so `/tf ir` on a broken flow
+ * yields a clean error table instead of crashing.
+ */
+export async function compileTaskflowToIR(def) {
+    const t = translateTaskflow(def);
+    let hash;
+    try {
+        hash = await flowDefHash(def);
+    }
+    catch {
+        hash = undefined;
+    }
+    return {
+        ir: t.ir,
+        meta: t.meta,
+        hash,
+        warnings: t.warnings,
+        errors: t.errors,
+        // Stub: the fallback hash is used whenever (a) any phase has a `when`
+        // (translateTaskflow flags it) OR (b) the hash computation itself failed.
+        // Once the genuine overstory compiler is vendored, condition (a) drops.
+        usedFallbackHash: t.usedFallbackHash || hash === undefined,
+    };
+}
+export { phaseFingerprint } from "./phasefp.js";
+//# sourceMappingURL=index.js.map

package/dist/flowir/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/flowir/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAGnD;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,GAAa;IACtD,MAAM,CAAC,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAC;IACjC,IAAI,IAAwB,CAAC;IAC7B,IAAI,CAAC;QACJ,IAAI,GAAG,MAAM,WAAW,CAAC,GAAG,CAAC,CAAC;IAC/B,CAAC;IAAC,MAAM,CAAC;QACR,IAAI,GAAG,SAAS,CAAC;IAClB,CAAC;IACD,OAAO;QACN,EAAE,EAAE,CAAC,CAAC,EAAE;QACR,IAAI,EAAE,CAAC,CAAC,IAAI;QACZ,IAAI;QACJ,QAAQ,EAAE,CAAC,CAAC,QAAQ;QACpB,MAAM,EAAE,CAAC,CAAC,MAAM;QAChB,sEAAsE;QACtE,0EAA0E;QAC1E,wEAAwE;QACxE,gBAAgB,EAAE,CAAC,CAAC,gBAAgB,IAAI,IAAI,KAAK,SAAS;KAC1D,CAAC;AACH,CAAC;AAYD,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC"}

package/dist/flowir/meta.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Type definitions for the FlowIR compile seam.
+ *
+ * This is the **stub/projection** layer of the overstory-convergence roadmap's
+ * M1 slice: we project a pi-taskflow `Taskflow` into a `FlowIR` shape that
+ * mirrors overstory's IR contract *structurally* (nodes with `inject`/`emits`)
+ * without yet compiling to overstory's native inject/emits model. The hash
+ * contract (overstory's `hashIR` algorithm) is shared via `flowDefHash` — see
+ * `./hash.ts`. When the genuine overstory compiler is vendored later, the
+ * `usedFallbackHash` flag flips to `false` and `ir` becomes the canonical IR;
+ * until then this seam is read-only, pure, and never throws.
+ *
+ * Pure module: no IO, no Date, no randomness. Type-only where possible.
+ *
+ * @see docs/internal/overstory-convergence-roadmap.md §3 (M1)
+ * @see docs/internal/rfc-flowir-compilation.md
+ */
+import type { Budget, Taskflow } from "../schema.ts";
+/**
+ * A phase's *declared* (static) dependency footprint, synthesized at compile
+ * time from `{steps.X}` interpolation refs (via `collectRefs`) plus `dependsOn`.
+ * `reads` = the upstream step ids this phase's task/when/branches/with/context
+ * statically reference; `writes` = the step id this phase emits (itself).
+ *
+ * This is the *declared* plane — distinct from the *observed* readSet captured
+ * at runtime (M3 `PhaseState.reads`). The two are reconciled by a **union**
+ * (`observed ∪ declared`) in `computeStaleFrontier` / `recomputeTaskflow` so a
+ * declared-but-unobserved edge (e.g. a `when` ref that never fired) is still
+ * treated as a dependency for staleness propagation. JSON-safe `Record` shape
+ * (not `Map`) so it round-trips through `RunState` persistence.
+ */
+export interface DeclaredDeps {
+    /** Upstream step ids statically referenced by this phase's interpolation. */
+    reads: string[];
+    /** Step id(s) this phase emits — currently `[phase.id]` (1:1 projection). */
+    writes: string[];
+}
+/**
+ * A single IR node — one per pi-taskflow phase. `kind` is the native phase type
+ * (a 1:1 projection; the overstory-native kind lowering is deferred per roadmap
+ * §6.1). `inject`/`emits` mirror overstory's contract: a node *injects*
+ * (reads) the outputs of its upstream nodes and *emits* (writes) its own.
+ */
+export interface FlowIRNode {
+    id: string;
+    /** pi-taskflow phase type (1:1 projection; `agent`|`parallel`|`map`|…). */
+    kind: string;
+    /** Synthesized declared reads: the `{steps.X}` refs this node's task
+     *  interpolates. (overstory-native `inject` lowering is deferred.) */
+    inject: string[];
+    /** What this node emits — currently `[id]` (1:1 projection). */
+    emits: string[];
+    /** Raw `when` guard passthrough (stub: not rewritten to IR conditions). */
+    when?: string;
+}
+/** The compiled IR: a flat list of nodes plus flow-level metadata. */
+export interface FlowIR {
+    name: string;
+    nodes: FlowIRNode[];
+    args?: Taskflow["args"];
+    budget?: Budget;
+    concurrency?: number;
+}
+/** A hard compile error (none in the stub; reserved for the genuine compiler). */
+export interface CompileError {
+    phaseId?: string;
+    code: string;
+    message: string;
+}
+/** A non-fatal advisory (e.g. a `{steps.X}` ref not reachable via dependsOn). */
+export interface CompileWarning {
+    phaseId?: string;
+    message: string;
+}
+/**
+ * Compile-time metadata attached to the IR. `declaredDeps` is the M2 declared
+ * plane (per-phase `DeclaredDeps`); `sidecar` carries every pi-taskflow-specific
+ * field not represented in `FlowIRNode` so the projection is lossless and can
+ * round-trip back to a runnable `Taskflow`.
+ */
+export interface TaskflowIRMeta {
+    sourceFlowName: string;
+    /** Per-phase declared dependency footprint (M2). JSON-safe. */
+    declaredDeps: Record<string, DeclaredDeps>;
+    /** Pi-taskflow-specific fields preserved verbatim for round-trip. */
+    sidecar: Record<string, unknown>;
+}
+/**
+ * The composite compile result (RFC §5). `ir`/`hash` are present unless
+ * synthesis failed (stub never fails). `usedFallbackHash` is `true` whenever
+ * the stub cannot produce an overstory-canonical hash (always, in the stub:
+ * the hash is the `flowDefHash` fallback; flips to `false` once the genuine
+ * compiler is vendored).
+ */
+export interface TaskflowIR {
+    ir?: FlowIR;
+    meta: TaskflowIRMeta;
+    hash?: string;
+    warnings: CompileWarning[];
+    errors: CompileError[];
+    usedFallbackHash: boolean;
+}
+//# sourceMappingURL=meta.d.ts.map

package/dist/flowir/meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta.d.ts","sourceRoot":"","sources":["../../src/flowir/meta.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAMrD;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,YAAY;IAC5B,6EAA6E;IAC7E,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,6EAA6E;IAC7E,MAAM,EAAE,MAAM,EAAE,CAAC;CACjB;AAMD;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb;0EACsE;IACtE,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,gEAAgE;IAChE,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,2EAA2E;IAC3E,IAAI,CAAC,EAAE,MAAM,CAAC;CACd;AAED,sEAAsE;AACtE,MAAM,WAAW,MAAM;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAMD,kFAAkF;AAClF,MAAM,WAAW,YAAY;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,iFAAiF;AACjF,MAAM,WAAW,cAAc;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CAChB;AAMD;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC9B,cAAc,EAAE,MAAM,CAAC;IACvB,+DAA+D;IAC/D,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC3C,qEAAqE;IACrE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IAC1B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,gBAAgB,EAAE,OAAO,CAAC;CAC1B"}

package/dist/flowir/meta.js

@@ -0,0 +1,19 @@
+/**
+ * Type definitions for the FlowIR compile seam.
+ *
+ * This is the **stub/projection** layer of the overstory-convergence roadmap's
+ * M1 slice: we project a pi-taskflow `Taskflow` into a `FlowIR` shape that
+ * mirrors overstory's IR contract *structurally* (nodes with `inject`/`emits`)
+ * without yet compiling to overstory's native inject/emits model. The hash
+ * contract (overstory's `hashIR` algorithm) is shared via `flowDefHash` — see
+ * `./hash.ts`. When the genuine overstory compiler is vendored later, the
+ * `usedFallbackHash` flag flips to `false` and `ir` becomes the canonical IR;
+ * until then this seam is read-only, pure, and never throws.
+ *
+ * Pure module: no IO, no Date, no randomness. Type-only where possible.
+ *
+ * @see docs/internal/overstory-convergence-roadmap.md §3 (M1)
+ * @see docs/internal/rfc-flowir-compilation.md
+ */
+export {};
+//# sourceMappingURL=meta.js.map

package/dist/flowir/meta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta.js","sourceRoot":"","sources":["../../src/flowir/meta.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG"}

package/dist/flowir/phasefp.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Per-phase structural sub-fingerprint (M6).
+ *
+ * `phaseFingerprint` produces a content-addressed hash of ONLY the subset of
+ * the flow definition that can affect a single phase's subagent output: the
+ * phase itself plus its transitive dependency closure. Folding this into the
+ * cross-run cache key (instead of the whole-flow `flowDefHash`) means editing
+ * phase B invalidates only B and its transitive dependents — independent
+ * sibling phase A keeps its cache hit.
+ *
+ * ## Soundness (the fallback gate)
+ *
+ * Per-phase invalidation is only sound when a phase's *real* dependencies are
+ * fully captured by the static `dependsOn ∪ from` closure. Three cases break
+ * that guarantee, so `phaseFingerprint` returns `undefined` for them and the
+ * caller falls back to the whole-flow `flowDefHash` (safe, = pre-M6 behavior):
+ *
+ *   1. **Shared Context Tree** (`def.contextSharing === true` or any closure
+ *      member has `shareContext === true`): a sharing phase can read sibling
+ *      blackboard writes OUTSIDE its declared deps, so the static closure
+ *      under-approximates real reads.
+ *   2. **`flow` phase in the closure** (`type === "flow"`): a `flow` phase's
+ *      sub-structure is resolved at runtime (inline `def`) or from a saved
+ *      flow (`use`) and is not statically visible here. Editing the saved
+ *      sub-flow would not move this phase's sub-fingerprint.
+ *   3. **`join: "any"` phase** (`phase.join === "any"`): validation exempts it
+ *      from the `{steps.X}`-must-be-in-`dependsOn` check, so it may read
+ *      phases outside its static closure. The closure under-approximates its
+ *      real reads, so fall back to whole-flow invalidation.
+ *
+ * `cache`, `retry`, `concurrency`, and `final` are stripped from each phase
+ * before hashing: none of them changes the subagent's OUTPUT (they are policy,
+ * execution mechanics, or result selection). `cache`'s sub-fields
+ * (`scope`/`ttl`/`fingerprint`) reach the cache key through other paths
+ * (`cc.scope` gates the lookup, `cc.ttlMs` governs expiry, `cc.fingerprint` is
+ * in the key tail). Every other `Phase` field is hashed. `PhaseSchema` uses
+ * `additionalProperties: false`, so no surprise field can be missed.
+ *
+ * Pure + async (Web Crypto via `hashCanonical`). Reuses the vendored
+ * `canonicalJson`/`hashCanonical` (byte-identical to overstory's contract) so
+ * the sub-fingerprint shares one hashing contract with `flowDefHash`. Never
+ * throws — callers wrap in try/catch and degrade to `flowDefHash`.
+ *
+ * @see docs/internal/cache-migration.md (v3:phasefp tier)
+ */
+import { type Taskflow } from "../schema.ts";
+/**
+ * Per-phase structural sub-fingerprint.
+ *
+ * @returns the hex hash, or `undefined` when per-phase soundness cannot be
+ *   guaranteed (caller falls back to the whole-flow `flowDefHash`). Never
+ *   throws.
+ */
+export declare function phaseFingerprint(def: Taskflow, phaseId: string): Promise<string | undefined>;
+//# sourceMappingURL=phasefp.d.ts.map

package/dist/flowir/phasefp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phasefp.d.ts","sourceRoot":"","sources":["../../src/flowir/phasefp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,OAAO,EAAsC,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC;AA0BjF;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAyClG"}

package/dist/flowir/phasefp.js

@@ -0,0 +1,123 @@
+/**
+ * Per-phase structural sub-fingerprint (M6).
+ *
+ * `phaseFingerprint` produces a content-addressed hash of ONLY the subset of
+ * the flow definition that can affect a single phase's subagent output: the
+ * phase itself plus its transitive dependency closure. Folding this into the
+ * cross-run cache key (instead of the whole-flow `flowDefHash`) means editing
+ * phase B invalidates only B and its transitive dependents — independent
+ * sibling phase A keeps its cache hit.
+ *
+ * ## Soundness (the fallback gate)
+ *
+ * Per-phase invalidation is only sound when a phase's *real* dependencies are
+ * fully captured by the static `dependsOn ∪ from` closure. Three cases break
+ * that guarantee, so `phaseFingerprint` returns `undefined` for them and the
+ * caller falls back to the whole-flow `flowDefHash` (safe, = pre-M6 behavior):
+ *
+ *   1. **Shared Context Tree** (`def.contextSharing === true` or any closure
+ *      member has `shareContext === true`): a sharing phase can read sibling
+ *      blackboard writes OUTSIDE its declared deps, so the static closure
+ *      under-approximates real reads.
+ *   2. **`flow` phase in the closure** (`type === "flow"`): a `flow` phase's
+ *      sub-structure is resolved at runtime (inline `def`) or from a saved
+ *      flow (`use`) and is not statically visible here. Editing the saved
+ *      sub-flow would not move this phase's sub-fingerprint.
+ *   3. **`join: "any"` phase** (`phase.join === "any"`): validation exempts it
+ *      from the `{steps.X}`-must-be-in-`dependsOn` check, so it may read
+ *      phases outside its static closure. The closure under-approximates its
+ *      real reads, so fall back to whole-flow invalidation.
+ *
+ * `cache`, `retry`, `concurrency`, and `final` are stripped from each phase
+ * before hashing: none of them changes the subagent's OUTPUT (they are policy,
+ * execution mechanics, or result selection). `cache`'s sub-fields
+ * (`scope`/`ttl`/`fingerprint`) reach the cache key through other paths
+ * (`cc.scope` gates the lookup, `cc.ttlMs` governs expiry, `cc.fingerprint` is
+ * in the key tail). Every other `Phase` field is hashed. `PhaseSchema` uses
+ * `additionalProperties: false`, so no surprise field can be missed.
+ *
+ * Pure + async (Web Crypto via `hashCanonical`). Reuses the vendored
+ * `canonicalJson`/`hashCanonical` (byte-identical to overstory's contract) so
+ * the sub-fingerprint shares one hashing contract with `flowDefHash`. Never
+ * throws — callers wrap in try/catch and degrade to `flowDefHash`.
+ *
+ * @see docs/internal/cache-migration.md (v3:phasefp tier)
+ */
+import { transitiveDependencies } from "../schema.js";
+import { canonicalJson, hashCanonical } from "./hash.js";
+/** Fields stripped before hashing because they do NOT affect a phase's
+ *  subagent OUTPUT, only execution mechanics or result selection — folding
+ *  them in would cause false cache invalidation on a no-op config change:
+ *   - `cache`: policy object; its sub-fields reach the key via
+ *     `cc.scope`/`cc.ttlMs`/`cc.fingerprint`.
+ *   - `retry`: retry/backoff is execution mechanics; a successful phase
+ *     produces the same output regardless of how many attempts it took.
+ *   - `concurrency`: fan-out parallelism; does not change any item's output.
+ *   - `final`: marks which phase's output is the flow result; does not change
+ *     the phase's own output. */
+const PHASE_FP_STRIP = ["cache", "retry", "concurrency", "final"];
+/** Clone a phase into a plain record with policy fields removed. */
+function stripPolicy(phase) {
+    const rec = phase;
+    const out = {};
+    for (const k of Object.keys(rec)) {
+        if (PHASE_FP_STRIP.includes(k))
+            continue;
+        out[k] = rec[k];
+    }
+    return out;
+}
+/**
+ * Per-phase structural sub-fingerprint.
+ *
+ * @returns the hex hash, or `undefined` when per-phase soundness cannot be
+ *   guaranteed (caller falls back to the whole-flow `flowDefHash`). Never
+ *   throws.
+ */
+export async function phaseFingerprint(def, phaseId) {
+    const phases = def.phases;
+    const byId = new Map(phases.map((p) => [p.id, p]));
+    const phase = byId.get(phaseId);
+    if (!phase)
+        return undefined;
+    // --- Soundness gate: fall back to whole-flow when static closure is unsafe. ---
+    // Flow-wide context sharing enables cross-sibling reads outside declared deps.
+    if (def.contextSharing === true)
+        return undefined;
+    // A `join: "any"` phase may interpolate `{steps.X.*}` refs to phases OUTSIDE
+    // its declared dependsOn (validation deliberately exempts it — schema.ts), so
+    // the static closure under-approximates its real reads. Fall back to
+    // whole-flow invalidation rather than rely on the key tail alone (which would
+    // be an undocumented coupling). Safe, = pre-M6 behavior.
+    if (phase.join === "any")
+        return undefined;
+    const closureIds = transitiveDependencies(phases, phaseId);
+    const closurePhases = [];
+    for (const id of closureIds) {
+        const p = byId.get(id);
+        if (!p)
+            continue; // unknown dep — validation reports elsewhere
+        // Per-phase sharing: this closure member can read sibling blackboard
+        // writes outside its own declared deps.
+        if (p.shareContext === true)
+            return undefined;
+        // A flow phase's sub-structure is runtime/saved-flow-resolved and not
+        // statically visible — editing it would not move the sub-fingerprint.
+        if ((p.type ?? "agent") === "flow")
+            return undefined;
+        closurePhases.push(p);
+    }
+    // The self phase's own sharing/type is part of the closure too.
+    if (phase.shareContext === true)
+        return undefined;
+    if ((phase.type ?? "agent") === "flow")
+        return undefined;
+    // --- Build the canonical payload. ---
+    // `deps` is the SORTED transitive closure (self excluded). canonicalJson
+    // sorts OBJECT keys but preserves ARRAY order, so we sort the array
+    // explicitly for determinism independent of dependency walk order.
+    const depsPayload = closurePhases.map((p) => ({ id: p.id, def: stripPolicy(p) }));
+    const payload = { self: stripPolicy(phase), deps: depsPayload };
+    return hashCanonical(canonicalJson(payload));
+}
+//# sourceMappingURL=phasefp.js.map

package/dist/flowir/phasefp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"phasefp.js","sourceRoot":"","sources":["../../src/flowir/phasefp.ts"],"names":[],"mappings":"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"}

package/dist/flowir/translate.d.ts

@@ -0,0 +1,37 @@
+/**
+ * FlowIR translation — the 1:1 projection of a pi-taskflow `Taskflow` into the
+ * `FlowIR` shape.
+ *
+ * **Stub/projection** (M1): this is a *structural* mirror, NOT a compile to
+ * overstory's native inject/emits model (which expects an explicit emit
+ * declaration pi-taskflow doesn't have — see roadmap §6.1). Each phase becomes
+ * one `FlowIRNode`; `inject` is synthesized from `{steps.X}` interpolation refs
+ * (`collectRefs`), `emits` is `[phase.id]`. The overstory-native `kind` lowering
+ * is deliberately deferred.
+ *
+ * Pure, synchronous, never throws. Used by `compileTaskflowToIR` (./index.ts).
+ *
+ * @see docs/internal/overstory-convergence-roadmap.md §3 (M1)
+ */
+import { type Taskflow } from "../schema.ts";
+import type { CompileError, CompileWarning, FlowIR, TaskflowIRMeta } from "./meta.ts";
+/**
+ * Translate a desugared `Taskflow` into a 1:1 `FlowIR` projection + declared
+ * dependency metadata. Never throws: malformed input yields warnings/errors in
+ * the return value, not an exception (so `/tf ir` on a broken flow still
+ * produces a structured diagnostic rather than crashing the tool).
+ *
+ * `usedFallbackHash` is `true` unconditionally in the stub: the hash produced
+ * is `flowDefHash` (the definition fingerprint), NOT the overstory-IR-canonical
+ * hash, so callers can never mistake a stub hash for a canonical one. It flips
+ * to `false` only once the genuine overstory compiler is vendored and the hash
+ * is IR-canonical; a `when` guard remains a *future* fallback driver then.
+ */
+export declare function translateTaskflow(def: Taskflow): {
+    ir: FlowIR;
+    meta: TaskflowIRMeta;
+    warnings: CompileWarning[];
+    errors: CompileError[];
+    usedFallbackHash: boolean;
+};
+//# sourceMappingURL=translate.d.ts.map

package/dist/flowir/translate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translate.d.ts","sourceRoot":"","sources":["../../src/flowir/translate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAA2B,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC;AACtE,OAAO,KAAK,EACX,YAAY,EACZ,cAAc,EAEd,MAAM,EAEN,cAAc,EACd,MAAM,WAAW,CAAC;AAwDnB;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,QAAQ,GAAG;IACjD,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,cAAc,CAAC;IACrB,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,gBAAgB,EAAE,OAAO,CAAC;CAC1B,CAgEA"}

package/dist/flowir/translate.js

@@ -0,0 +1,137 @@
+/**
+ * FlowIR translation — the 1:1 projection of a pi-taskflow `Taskflow` into the
+ * `FlowIR` shape.
+ *
+ * **Stub/projection** (M1): this is a *structural* mirror, NOT a compile to
+ * overstory's native inject/emits model (which expects an explicit emit
+ * declaration pi-taskflow doesn't have — see roadmap §6.1). Each phase becomes
+ * one `FlowIRNode`; `inject` is synthesized from `{steps.X}` interpolation refs
+ * (`collectRefs`), `emits` is `[phase.id]`. The overstory-native `kind` lowering
+ * is deliberately deferred.
+ *
+ * Pure, synchronous, never throws. Used by `compileTaskflowToIR` (./index.ts).
+ *
+ * @see docs/internal/overstory-convergence-roadmap.md §3 (M1)
+ */
+import { collectRefs } from "../schema.js";
+// ---------------------------------------------------------------------------
+// Sidecar: the pi-taskflow-specific fields not represented in FlowIRNode.
+// Everything preserved verbatim so the projection is lossless and can
+// round-trip back to a runnable Taskflow. Defined as a list so the sidecar
+// never silently drops a field when the DSL grows (a new field is carried
+// automatically through `Phase` indexing).
+// ---------------------------------------------------------------------------
+const SIDECAR_PHASE_FIELDS = [
+    "task",
+    "over",
+    "as",
+    "branches",
+    "from",
+    "use",
+    "def",
+    "with",
+    "until",
+    "maxIterations",
+    "convergence",
+    "variants",
+    "judge",
+    "judgeAgent",
+    "mode",
+    "dependsOn",
+    "join",
+    "when",
+    "retry",
+    "output",
+    "model",
+    "thinking",
+    "tools",
+    "cwd",
+    "context",
+    "contextLimit",
+    "onBlock",
+    "eval",
+    "cache",
+    "shareContext",
+    "optional",
+    "final",
+    "concurrency",
+];
+/** Build the per-phase sidecar record (verbatim copy of non-IR fields). */
+function sidecarForPhase(phase) {
+    const out = {};
+    const rec = phase;
+    for (const k of SIDECAR_PHASE_FIELDS) {
+        if (k in rec && rec[k] !== undefined)
+            out[k] = rec[k];
+    }
+    return out;
+}
+/**
+ * Translate a desugared `Taskflow` into a 1:1 `FlowIR` projection + declared
+ * dependency metadata. Never throws: malformed input yields warnings/errors in
+ * the return value, not an exception (so `/tf ir` on a broken flow still
+ * produces a structured diagnostic rather than crashing the tool).
+ *
+ * `usedFallbackHash` is `true` unconditionally in the stub: the hash produced
+ * is `flowDefHash` (the definition fingerprint), NOT the overstory-IR-canonical
+ * hash, so callers can never mistake a stub hash for a canonical one. It flips
+ * to `false` only once the genuine overstory compiler is vendored and the hash
+ * is IR-canonical; a `when` guard remains a *future* fallback driver then.
+ */
+export function translateTaskflow(def) {
+    const warnings = [];
+    const errors = [];
+    const declaredDeps = {};
+    const sidecarPhases = {};
+    // In the stub the hash is ALWAYS the fallback (flowDefHash — the definition
+    // fingerprint, not the overstory-IR-canonical hash). The `when` guard is a
+    // *future* driver (the genuine compiler can't lower conditions → fallback);
+    // today the stub unconditionally uses the fallback so callers can never
+    // mistake a stub hash for a canonical one. Flips to `false` only once the
+    // genuine overstory compiler is vendored and the hash is IR-canonical.
+    const usedFallbackHash = true;
+    const nodes = def.phases.map((phase) => {
+        const refs = collectRefs(phase);
+        // declared reads: the {steps.X} refs this phase statically references.
+        const reads = refs.steps.filter((id) => id !== phase.id);
+        declaredDeps[phase.id] = { reads, writes: [phase.id] };
+        // Advisory: a {steps.X} ref whose target doesn't exist (mirrors the
+        // validation check but non-fatal here — validation is the source of
+        // truth; this is a read-only diagnostic).
+        const knownIds = new Set(def.phases.map((p) => p.id));
+        for (const r of refs.steps) {
+            if (r !== phase.id && !knownIds.has(r)) {
+                warnings.push({
+                    phaseId: phase.id,
+                    message: `references {steps.${r}.*} but no phase '${r}' exists`,
+                });
+            }
+        }
+        if (phase.when !== undefined) {
+            // `when` is a future fallback driver; today the stub is always fallback.
+            // (Kept as a structural marker on the node for round-trip.)
+        }
+        sidecarPhases[phase.id] = sidecarForPhase(phase);
+        return {
+            id: phase.id,
+            kind: phase.type ?? "agent",
+            inject: reads,
+            emits: [phase.id],
+            when: phase.when,
+        };
+    });
+    const ir = {
+        name: def.name,
+        nodes,
+        args: def.args,
+        budget: def.budget,
+        concurrency: def.concurrency,
+    };
+    const meta = {
+        sourceFlowName: def.name,
+        declaredDeps,
+        sidecar: { phases: sidecarPhases },
+    };
+    return { ir, meta, warnings, errors, usedFallbackHash };
+}
+//# sourceMappingURL=translate.js.map

package/dist/flowir/translate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"translate.js","sourceRoot":"","sources":["../../src/flowir/translate.ts"],"names":[],"mappings":"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"}

package/dist/frontmatter.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Minimal YAML-frontmatter parser for agent `.md` files.
+ *
+ * Vendored so taskflow-core stays dependency-free (the host SDK's
+ * `parseFrontmatter` pulls in the `yaml` package). Agent frontmatter is flat
+ * `key: value` — scalars, quoted strings, comma lists, or inline `[a, b]`
+ * sequences — which is all this parser needs to support. Anything it can't
+ * parse degrades to a string value (the caller already tolerates that).
+ */
+export interface Frontmatter {
+    frontmatter: Record<string, unknown>;
+    body: string;
+}
+/**
+ * Parse frontmatter from a markdown file. Returns `{ frontmatter, body }`.
+ * Lines that aren't `key: value` (e.g. block sequences) are skipped; the caller
+ * only relies on flat keys.
+ */
+export declare function parseFrontmatter(content: string): Frontmatter;
+export declare const stripFrontmatter: (content: string) => string;
+//# sourceMappingURL=frontmatter.d.ts.map

package/dist/frontmatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontmatter.d.ts","sourceRoot":"","sources":["../src/frontmatter.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,WAAW,WAAW;IAC3B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,IAAI,EAAE,MAAM,CAAC;CACb;AAyCD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,CAuC7D;AAED,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,KAAG,MAAwC,CAAC"}