@petepetrash/circuit 0.1.0

package/dist/flows/resolvers/signals.js

@@ -0,0 +1,273 @@
+// Resolver #0 — task signals (the NL-to-signals reader).
+//
+// The custom-flow seam used to be task-BLIND: it threw the description away and
+// hardcoded surface_area:'small'/risk:'low', so the only shape it could ever
+// emit was build's spine (folded or full). This resolver READS the one-line task
+// description into the coarse signals the assembler actually needs: which
+// archetype FAMILY the task belongs to, how much surface it touches, and how
+// risky it is. The signals it derives are the same axes the hand-authored flows
+// were shaped around, so picking a family from them lets the assembler
+// instantiate a task-appropriate shape instead of always reaching for build.
+//
+// Engine boundary: this stays cleanly OUTSIDE the engine. It is pure string
+// classification over public vocabulary — no engine dependency, no IO, no model
+// call. The cue lists are exported data so the report and tests can cite them and
+// so the vocabulary rides the data, not engine code.
+//
+// Deterministic by construction: the same description always yields the same
+// signals. That determinism is a pre-registered acceptance gate (the breadth
+// harness generates N=10 per task and requires identical shapes every time).
+// Family cue lists, ordered by classification PRECEDENCE (first match wins).
+// The order reflects how reliably each cue carries the task's actionable intent:
+// fix / prototype / editorial verbs are near-unambiguous, so they win over the
+// softer review / research cues that can merely precede a build. build is the
+// fallthrough default — the conservative choice when no cue fires.
+//
+// Two cue kinds (see cueMatcher):
+//   - WHOLE-WORD cues ('fix', 'audit', 'explore') match the word plus its simple
+//     inflections (-s/-es/-ed/-ing) and NOTHING else: 'fix' fires on fix/fixes/
+//     fixing but never inside 'fixture', 'audit' never inside 'auditorium',
+//     'explore' never inside 'explorer'. This is the default and what kills the
+//     derivational-collision class.
+//   - STEM cues, marked with a trailing '*' ('migrat*', 'investigat*'), match
+//     from a word-boundary START with no trailing anchor, so a deliberately
+//     truncated stem fires across a whole inflection family ('migrat*' →
+//     migration/migrating). Use only where the stem has no unwanted
+//     longer-word neighbour.
+// Either kind anchors the START at a word boundary, so a cue never fires mid-word
+// ('hang' cannot match inside "changelog"). Cues curated to avoid common-noun
+// collisions (e.g. no bare 'option', which would fire on "add an options page").
+export const FAMILY_CUES = [
+    {
+        family: 'fix',
+        cues: [
+            'fix',
+            'bug',
+            'broken',
+            'crash',
+            'regression',
+            'failing',
+            'flaky',
+            'repro*',
+            'defect',
+            'memory leak',
+            'race condition',
+            'deadlock',
+            'hang',
+            "doesn't work",
+            'does not work',
+            'not working',
+            'misbehav*',
+        ],
+    },
+    {
+        family: 'prototype',
+        cues: [
+            'prototype',
+            'mockup',
+            'mock up',
+            'mock-up',
+            'proof of concept',
+            'proof-of-concept',
+            'wireframe',
+            'visual direction',
+            'design exploration',
+            'experiment with the ui',
+        ],
+    },
+    {
+        family: 'editorial',
+        cues: [
+            'explain',
+            'explanation',
+            'teach',
+            'tutorial',
+            'walkthrough',
+            'walk through',
+            'interactive explainer',
+            'explainer',
+            'demystif*',
+            'intuition for',
+            'visualize how',
+            'illustrate how',
+        ],
+    },
+    {
+        family: 'review',
+        cues: ['review', 'audit', 'inspect', 'critique', 'assess', 'look over', 'go over the'],
+    },
+    {
+        family: 'research',
+        cues: [
+            'research',
+            'investigat*',
+            'explore',
+            'compar*',
+            'evaluate option',
+            'options for',
+            'spike',
+            'analyze',
+            'analysis',
+            'figure out',
+            'trade-off',
+            'tradeoff',
+        ],
+    },
+];
+// Surface-area cues. A large surface earns the decomposed (full-spine) build
+// grain; otherwise the build family leans conservative-whole.
+export const LARGE_SURFACE_CUES = [
+    'migrat*',
+    'across every',
+    'across all',
+    'across the',
+    'system-wide',
+    'systemwide',
+    'entire',
+    'rewrite',
+    'whole codebase',
+    'end-to-end',
+    'throughout',
+    'every service',
+    'all services',
+];
+export const MEDIUM_SURFACE_CUES = [
+    'refactor',
+    'several',
+    'multiple',
+    'subsystem',
+    'integrat*',
+    'overhaul',
+];
+// Risk cues. High-risk subjects (auth, money, data, production) escalate risk,
+// which (for the build family) also earns the decomposed grain so the full
+// review + verification spine survives.
+export const HIGH_RISK_CUES = [
+    'auth*',
+    'security',
+    'password',
+    'credential',
+    'payment',
+    'billing',
+    'production',
+    'migrat*',
+    'data loss',
+    'breaking change',
+    'encryption',
+    'secret',
+    'irreversible',
+];
+export const MEDIUM_RISK_CUES = [
+    'database',
+    'schema',
+    'api',
+    'concurrency',
+    'race',
+    'performance',
+    'permission',
+    'access control',
+];
+// Coarse subject labels for legibility (operator summary + trace). Order matters
+// only for which label is reported first; it never affects the shape.
+const DOMAIN_CUES = [
+    ['auth', ['auth*', 'login', 'password', 'credential', 'session']],
+    ['billing', ['billing', 'payment', 'invoice', 'subscription', 'pricing']],
+    ['data', ['database', 'schema', 'migration', 'data model', 'query']],
+    ['api', ['api', 'endpoint', 'route handler', 'rest', 'graphql']],
+    ['ui', ['ui', 'page', 'component', 'button', 'layout', 'hero', 'styling', 'css']],
+    ['docs', ['docs', 'documentation', 'readme', 'release note', 'tutorial']],
+    ['perf', ['performance', 'latency', 'throughput', 'slow', 'optimize']],
+];
+// The human-readable form of a cue (drops the stem '*' marker), for signals_used
+// trace lines: the cue 'migrat*' is reported as "migrat".
+export function cueLabel(cue) {
+    return cue.endsWith('*') ? cue.slice(0, -1) : cue;
+}
+// Compiled matchers, cached per cue. Every cue anchors its START at a word
+// boundary, so a cue never fires mid-word ('hang' cannot match inside
+// "changelog" — no boundary before the 'h'). The trailing anchor differs by kind:
+//   - STEM cue ('migrat*'): no trailing anchor, so the truncated stem fires
+//     across its whole inflection family (migration/migrating).
+//   - WHOLE-WORD cue ('fix'): a trailing boundary that permits only simple
+//     inflectional suffixes (-s/-es/-ed/-ing). This matches fix/fixes/fixing but
+//     NOT 'fixture', 'audit' but not 'auditorium', 'explore' but not 'explorer' —
+//     the derivational-noun collision class a bare start-anchor would let through.
+const cueMatchers = new Map();
+function cueMatcher(cue) {
+    const cached = cueMatchers.get(cue);
+    if (cached !== undefined)
+        return cached;
+    const isStem = cue.endsWith('*');
+    const literal = isStem ? cue.slice(0, -1) : cue;
+    const escaped = literal.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const matcher = isStem
+        ? new RegExp(`\\b${escaped}`)
+        : new RegExp(`\\b${escaped}(?:s|es|ed|ing)?\\b`);
+    cueMatchers.set(cue, matcher);
+    return matcher;
+}
+function firstMatchingCue(haystack, cues) {
+    return cues.find((cue) => cueMatcher(cue).test(haystack));
+}
+function classifyFamily(text) {
+    for (const { family, cues } of FAMILY_CUES) {
+        const cue = firstMatchingCue(text, cues);
+        if (cue !== undefined)
+            return { family, cue };
+    }
+    return { family: 'build', cue: undefined };
+}
+function classifySurface(text) {
+    const large = firstMatchingCue(text, LARGE_SURFACE_CUES);
+    if (large !== undefined)
+        return { surface: 'large', cue: large };
+    const medium = firstMatchingCue(text, MEDIUM_SURFACE_CUES);
+    if (medium !== undefined)
+        return { surface: 'medium', cue: medium };
+    return { surface: 'small', cue: undefined };
+}
+function classifyRisk(text) {
+    const high = firstMatchingCue(text, HIGH_RISK_CUES);
+    if (high !== undefined)
+        return { risk: 'high', cue: high };
+    const medium = firstMatchingCue(text, MEDIUM_RISK_CUES);
+    if (medium !== undefined)
+        return { risk: 'medium', cue: medium };
+    return { risk: 'low', cue: undefined };
+}
+function classifyDomain(text) {
+    for (const [label, cues] of DOMAIN_CUES) {
+        if (firstMatchingCue(text, cues) !== undefined)
+            return label;
+    }
+    return null;
+}
+// Read a one-line task description into the assembler's signals. Deterministic,
+// pure, lowercase-normalized substring classification.
+export function extractAssemblySignals(description, options = {}) {
+    const text = ` ${description.toLowerCase().trim()} `;
+    const used = [];
+    const { family, cue: familyCue } = classifyFamily(text);
+    if (familyCue !== undefined)
+        used.push(`family:${family} (matched "${cueLabel(familyCue)}")`);
+    const { surface, cue: surfaceCue } = classifySurface(text);
+    if (surfaceCue !== undefined) {
+        used.push(`surface:${surface} (matched "${cueLabel(surfaceCue)}")`);
+    }
+    const { risk, cue: riskCue } = classifyRisk(text);
+    if (riskCue !== undefined)
+        used.push(`risk:${risk} (matched "${cueLabel(riskCue)}")`);
+    const domain = classifyDomain(text);
+    if (domain !== null)
+        used.push(`domain:${domain}`);
+    return {
+        summary: description,
+        surface_area: surface,
+        risk,
+        family,
+        domain,
+        explicit_decompose: options.explicit_decompose === true,
+        signals_used: used,
+    };
+}
+//# sourceMappingURL=signals.js.map

package/dist/flows/resolvers/signals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signals.js","sourceRoot":"","sources":["../../../src/flows/resolvers/signals.ts"],"names":[],"mappings":"AAAA,yDAAyD;AACzD,EAAE;AACF,gFAAgF;AAChF,6EAA6E;AAC7E,iFAAiF;AACjF,0EAA0E;AAC1E,6EAA6E;AAC7E,gFAAgF;AAChF,uEAAuE;AACvE,6EAA6E;AAC7E,EAAE;AACF,4EAA4E;AAC5E,gFAAgF;AAChF,kFAAkF;AAClF,qDAAqD;AACrD,EAAE;AACF,6EAA6E;AAC7E,6EAA6E;AAC7E,6EAA6E;AAmC7E,6EAA6E;AAC7E,iFAAiF;AACjF,+EAA+E;AAC/E,8EAA8E;AAC9E,mEAAmE;AACnE,EAAE;AACF,kCAAkC;AAClC,iFAAiF;AACjF,gFAAgF;AAChF,4EAA4E;AAC5E,gFAAgF;AAChF,oCAAoC;AACpC,8EAA8E;AAC9E,4EAA4E;AAC5E,yEAAyE;AACzE,oEAAoE;AACpE,6BAA6B;AAC7B,kFAAkF;AAClF,8EAA8E;AAC9E,iFAAiF;AACjF,MAAM,CAAC,MAAM,WAAW,GAAsB;IAC5C;QACE,MAAM,EAAE,KAAK;QACb,IAAI,EAAE;YACJ,KAAK;YACL,KAAK;YACL,QAAQ;YACR,OAAO;YACP,YAAY;YACZ,SAAS;YACT,OAAO;YACP,QAAQ;YACR,QAAQ;YACR,aAAa;YACb,gBAAgB;YAChB,UAAU;YACV,MAAM;YACN,cAAc;YACd,eAAe;YACf,aAAa;YACb,WAAW;SACZ;KACF;IACD;QACE,MAAM,EAAE,WAAW;QACnB,IAAI,EAAE;YACJ,WAAW;YACX,QAAQ;YACR,SAAS;YACT,SAAS;YACT,kBAAkB;YAClB,kBAAkB;YAClB,WAAW;YACX,kBAAkB;YAClB,oBAAoB;YACpB,wBAAwB;SACzB;KACF;IACD;QACE,MAAM,EAAE,WAAW;QACnB,IAAI,EAAE;YACJ,SAAS;YACT,aAAa;YACb,OAAO;YACP,UAAU;YACV,aAAa;YACb,cAAc;YACd,uBAAuB;YACvB,WAAW;YACX,WAAW;YACX,eAAe;YACf,eAAe;YACf,gBAAgB;SACjB;KACF;IACD;QACE,MAAM,EAAE,QAAQ;QAChB,IAAI,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,EAAE,aAAa,CAAC;KACvF;IACD;QACE,MAAM,EAAE,UAAU;QAClB,IAAI,EAAE;YACJ,UAAU;YACV,aAAa;YACb,SAAS;YACT,SAAS;YACT,iBAAiB;YACjB,aAAa;YACb,OAAO;YACP,SAAS;YACT,UAAU;YACV,YAAY;YACZ,WAAW;YACX,UAAU;SACX;KACF;CACF,CAAC;AAEF,6EAA6E;AAC7E,8DAA8D;AAC9D,MAAM,CAAC,MAAM,kBAAkB,GAAsB;IACnD,SAAS;IACT,cAAc;IACd,YAAY;IACZ,YAAY;IACZ,aAAa;IACb,YAAY;IACZ,QAAQ;IACR,SAAS;IACT,gBAAgB;IAChB,YAAY;IACZ,YAAY;IACZ,eAAe;IACf,cAAc;CACf,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAsB;IACpD,UAAU;IACV,SAAS;IACT,UAAU;IACV,WAAW;IACX,WAAW;IACX,UAAU;CACX,CAAC;AAEF,+EAA+E;AAC/E,2EAA2E;AAC3E,wCAAwC;AACxC,MAAM,CAAC,MAAM,cAAc,GAAsB;IAC/C,OAAO;IACP,UAAU;IACV,UAAU;IACV,YAAY;IACZ,SAAS;IACT,SAAS;IACT,YAAY;IACZ,SAAS;IACT,WAAW;IACX,iBAAiB;IACjB,YAAY;IACZ,QAAQ;IACR,cAAc;CACf,CAAC;AAEF,MAAM,CAAC,MAAM,gBAAgB,GAAsB;IACjD,UAAU;IACV,QAAQ;IACR,KAAK;IACL,aAAa;IACb,MAAM;IACN,aAAa;IACb,YAAY;IACZ,gBAAgB;CACjB,CAAC;AAEF,iFAAiF;AACjF,sEAAsE;AACtE,MAAM,WAAW,GAAsD;IACrE,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,SAAS,CAAC,CAAC;IACjE,CAAC,SAAS,EAAE,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,cAAc,EAAE,SAAS,CAAC,CAAC;IACzE,CAAC,MAAM,EAAE,CAAC,UAAU,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;IACpE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;IAChE,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;IACjF,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,eAAe,EAAE,QAAQ,EAAE,cAAc,EAAE,UAAU,CAAC,CAAC;IACzE,CAAC,MAAM,EAAE,CAAC,aAAa,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;CACvE,CAAC;AAEF,iFAAiF;AACjF,0DAA0D;AAC1D,MAAM,UAAU,QAAQ,CAAC,GAAW;IAClC,OAAO,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;AACpD,CAAC;AAED,2EAA2E;AAC3E,sEAAsE;AACtE,kFAAkF;AAClF,4EAA4E;AAC5E,gEAAgE;AAChE,2EAA2E;AAC3E,iFAAiF;AACjF,kFAAkF;AAClF,mFAAmF;AACnF,MAAM,WAAW,GAAG,IAAI,GAAG,EAAkB,CAAC;AAC9C,SAAS,UAAU,CAAC,GAAW;IAC7B,MAAM,MAAM,GAAG,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACpC,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC;IACxC,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;IACjC,MAAM,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;IAChD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;IAC/D,MAAM,OAAO,GAAG,MAAM;QACpB,CAAC,CAAC,IAAI,MAAM,CAAC,MAAM,OAAO,EAAE,CAAC;QAC7B,CAAC,CAAC,IAAI,MAAM,CAAC,MAAM,OAAO,qBAAqB,CAAC,CAAC;IACnD,WAAW,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IAC9B,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,SAAS,gBAAgB,CAAC,QAAgB,EAAE,IAAuB;IACjE,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;AAC5D,CAAC;AAED,SAAS,cAAc,CAAC,IAAY;IAClC,KAAK,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,WAAW,EAAE,CAAC;QAC3C,MAAM,GAAG,GAAG,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACzC,IAAI,GAAG,KAAK,SAAS;YAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;IAChD,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC;AAC7C,CAAC;AAED,SAAS,eAAe,CAAC,IAAY;IACnC,MAAM,KAAK,GAAG,gBAAgB,CAAC,IAAI,EAAE,kBAAkB,CAAC,CAAC;IACzD,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC;IACjE,MAAM,MAAM,GAAG,gBAAgB,CAAC,IAAI,EAAE,mBAAmB,CAAC,CAAC;IAC3D,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC;IACpE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC;AAC9C,CAAC;AAED,SAAS,YAAY,CAAC,IAAY;IAChC,MAAM,IAAI,GAAG,gBAAgB,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IACpD,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC;IAC3D,MAAM,MAAM,GAAG,gBAAgB,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAC;IACxD,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC;IACjE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC;AACzC,CAAC;AAED,SAAS,cAAc,CAAC,IAAY;IAClC,KAAK,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,WAAW,EAAE,CAAC;QACxC,IAAI,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,SAAS;YAAE,OAAO,KAAK,CAAC;IAC/D,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,gFAAgF;AAChF,uDAAuD;AACvD,MAAM,UAAU,sBAAsB,CACpC,WAAmB,EACnB,UAAqD,EAAE;IAEvD,MAAM,IAAI,GAAG,IAAI,WAAW,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACrD,MAAM,IAAI,GAAa,EAAE,CAAC;IAE1B,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;IACxD,IAAI,SAAS,KAAK,SAAS;QAAE,IAAI,CAAC,IAAI,CAAC,UAAU,MAAM,cAAc,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAE9F,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,UAAU,EAAE,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;IAC3D,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;QAC7B,IAAI,CAAC,IAAI,CAAC,WAAW,OAAO,cAAc,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IACtE,CAAC;IAED,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;IAClD,IAAI,OAAO,KAAK,SAAS;QAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,cAAc,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtF,MAAM,MAAM,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;IACpC,IAAI,MAAM,KAAK,IAAI;QAAE,IAAI,CAAC,IAAI,CAAC,UAAU,MAAM,EAAE,CAAC,CAAC;IAEnD,OAAO;QACL,OAAO,EAAE,WAAW;QACpB,YAAY,EAAE,OAAO;QACrB,IAAI;QACJ,MAAM;QACN,MAAM;QACN,kBAAkB,EAAE,OAAO,CAAC,kBAAkB,KAAK,IAAI;QACvD,YAAY,EAAE,IAAI;KACnB,CAAC;AACJ,CAAC"}

package/dist/flows/resolvers/structure.d.ts

@@ -0,0 +1,23 @@
+import type { FlowSchematicAssemblySpec } from '../assemble-flow-schematic.js';
+export type StructureGrain = 'whole' | 'decomposed';
+export interface StructureTaskContext {
+    readonly summary: string;
+    readonly surface_area: 'small' | 'medium' | 'large';
+    readonly risk: 'low' | 'medium' | 'high';
+    readonly explicit_decompose?: boolean;
+}
+export type PriorChoices = Readonly<Record<string, string>>;
+export interface StructureResolution {
+    readonly axis: 'structure';
+    readonly choice: StructureGrain;
+    readonly binding_time: 'assembly';
+    readonly enforcement: 'enforced';
+    readonly rationale: string;
+}
+export declare function resolveStructure(task: StructureTaskContext, _prior?: PriorChoices): StructureResolution;
+export declare function applyStructure(seed: FlowSchematicAssemblySpec, resolution: StructureResolution): FlowSchematicAssemblySpec;
+export declare function resolveAndApplyStructure(seed: FlowSchematicAssemblySpec, task: StructureTaskContext, prior?: PriorChoices): {
+    readonly resolution: StructureResolution;
+    readonly spec: FlowSchematicAssemblySpec;
+};
+//# sourceMappingURL=structure.d.ts.map

package/dist/flows/resolvers/structure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structure.d.ts","sourceRoot":"","sources":["../../../src/flows/resolvers/structure.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAM/E,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,YAAY,CAAC;AAIpD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,YAAY,EAAE,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;IACpD,QAAQ,CAAC,IAAI,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IAEzC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;CACvC;AAKD,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAS5D,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,YAAY,EAAE,UAAU,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,UAAU,CAAC;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAOD,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,oBAAoB,EAC1B,MAAM,GAAE,YAAiB,GACxB,mBAAmB,CAsBrB;AAoED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,yBAAyB,EAC/B,UAAU,EAAE,mBAAmB,GAC9B,yBAAyB,CAW3B;AAGD,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,yBAAyB,EAC/B,IAAI,EAAE,oBAAoB,EAC1B,KAAK,GAAE,YAAiB,GACvB;IAAE,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAA;CAAE,CAGxF"}

package/dist/flows/resolvers/structure.js

@@ -0,0 +1,112 @@
+// The chooser: (task context, prior choices) -> one choice for the structure
+// axis. Conservative — it leans to `whole` and only chops when a decompose
+// signal is unambiguous (an explicit ask, a large surface, or high risk). This
+// is the thin-conservative default the B2 brief mandates: lean to whole, chop
+// only on a clear signal.
+export function resolveStructure(task, _prior = {}) {
+    const reasons = [];
+    if (task.explicit_decompose === true)
+        reasons.push('operator asked to decompose');
+    if (task.surface_area === 'large')
+        reasons.push('large surface area');
+    if (task.risk === 'high')
+        reasons.push('high risk');
+    if (reasons.length > 0) {
+        return {
+            axis: 'structure',
+            choice: 'decomposed',
+            binding_time: 'assembly',
+            enforcement: 'enforced',
+            rationale: `Chop: ${reasons.join(', ')}.`,
+        };
+    }
+    return {
+        axis: 'structure',
+        choice: 'whole',
+        binding_time: 'assembly',
+        enforcement: 'enforced',
+        rationale: 'Hold (conservative default): no strong decompose signal, so one folded work spine.',
+    };
+}
+// The step ids the fold-to-whole transform removes from build's spine. The thin
+// resolver folds build's known spine; a GENERAL fold that computes droppable
+// stages from the contract DAG is the E4 planner's job (the ratification item).
+// These four are the analyze relay, the two auxiliary verify checks, and the
+// review relay — folding them leaves frame -> plan -> act -> verify -> close.
+const WHOLE_FOLD_DROP_IDS = [
+    'analyze-step',
+    'build-baseline',
+    'build-touch-area',
+    'review-step',
+];
+const clone = (value) => JSON.parse(JSON.stringify(value));
+// Fold a seed's spine to the whole grain: drop the named steps, prune the
+// dropped producers' output contracts from every surviving input map, and rewire
+// any route that pointed at a dropped step forward to its first surviving
+// successor (following `continue`). The assembler then records the now-absent
+// canonical stages as declared omits + the rationale, so the result is an
+// honestly-narrowed flow, not a silently-broken one.
+function foldToWhole(seed, dropIds) {
+    const drop = new Set(dropIds);
+    const items = seed.items;
+    const droppedContracts = new Set();
+    for (const item of items) {
+        if (drop.has(item.id) && typeof item.output === 'string') {
+            droppedContracts.add(item.output);
+        }
+    }
+    const byId = new Map(items.map((item) => [item.id, item]));
+    const redirect = (target, seen = new Set()) => {
+        if (!drop.has(target))
+            return target;
+        if (seen.has(target))
+            return '@stop';
+        seen.add(target);
+        const dropped = byId.get(target);
+        const next = dropped?.routes?.continue ?? '@stop';
+        return redirect(next, seen);
+    };
+    return items
+        .filter((item) => !drop.has(item.id))
+        .map((item) => {
+        const copy = clone(item);
+        const input = copy.input;
+        if (input) {
+            for (const [key, contract] of Object.entries(input)) {
+                if (droppedContracts.has(contract))
+                    delete input[key];
+            }
+        }
+        const routes = {};
+        for (const [outcome, target] of Object.entries(copy.routes)) {
+            routes[outcome] = redirect(target);
+        }
+        return { ...copy, input: input, routes: routes };
+    });
+}
+// Materialize a structure resolution onto a seed assembly spec. `decomposed`
+// returns the seed's full spine; `whole` folds it to one folded work spine. The
+// result is a spec ready for `assembleFlowSchematic` — the resolver rides the
+// assembler, it does not special-case the engine.
+//
+// Note: this stamps a grain suffix onto `seed.id` so the two materializations of
+// the same seed are distinguishable in offline measurement. Callers that need a
+// specific id (custom-flow create wants the slug) should re-set `id` on the
+// returned spec.
+export function applyStructure(seed, resolution) {
+    if (resolution.choice === 'decomposed') {
+        return { ...clone(seed), id: `${seed.id}-decomposed` };
+    }
+    return {
+        ...clone(seed),
+        id: `${seed.id}-whole`,
+        items: foldToWhole(seed, WHOLE_FOLD_DROP_IDS),
+        stagePathRationale: 'Whole grain: analyze folds into act and review folds into close; one folded work spine.',
+    };
+}
+// One call: resolve the grain for a task and materialize it onto the seed.
+export function resolveAndApplyStructure(seed, task, prior = {}) {
+    const resolution = resolveStructure(task, prior);
+    return { resolution, spec: applyStructure(seed, resolution) };
+}
+//# sourceMappingURL=structure.js.map

package/dist/flows/resolvers/structure.js.map

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

package/dist/flows/review/assembly-spec.d.ts

@@ -0,0 +1,5 @@
+import type { FlowSchematicAssemblySpec } from '../assemble-flow-schematic.js';
+import type { BlockStepUse } from '../block-step-expansion.js';
+export declare const reviewBlockItems: readonly BlockStepUse[];
+export declare const reviewAssemblySpec: FlowSchematicAssemblySpec;
+//# sourceMappingURL=assembly-spec.d.ts.map

package/dist/flows/review/assembly-spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assembly-spec.d.ts","sourceRoot":"","sources":["../../../src/flows/review/assembly-spec.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,yBAAyB,EAAiB,MAAM,+BAA+B,CAAC;AAC9F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAO/D,eAAO,MAAM,gBAAgB,EAAE,SAAS,YAAY,EAmDnD,CAAC;AAQF,eAAO,MAAM,kBAAkB,EAAE,yBA8BhC,CAAC"}

package/dist/flows/review/assembly-spec.js

@@ -0,0 +1,90 @@
+const REVIEW_STAGE_PATH_RATIONALE = 'Review is an audit-only flow: Intake frames the scope, Independent Audit performs the reviewer relay, and Verdict aggregates findings. There is no planning stage, no implementation/action stage, no verification rerun, and no nested review stage in this narrowed variant.';
+// Review's full block sequence, in route order. It touches only the frame,
+// analyze, and close canonical stages.
+export const reviewBlockItems = [
+    // Review's intake is a structurally distinct frame: it captures the
+    // working-tree state to audit against, not the generic scope/constraints/
+    // proof-plan a build-style frame produces. It uses the dedicated
+    // review-intake block, so its output and evidence are inherited from the
+    // block rather than restated here.
+    {
+        id: 'intake-step',
+        title: 'Intake — resolve review scope',
+        stage: 'frame',
+        block: 'review-intake',
+        input: { task: 'task.intake@v1', route: 'route.decision@v1' },
+        protocol: 'review-intake@v1',
+        reportPath: 'reports/review-intake.json',
+        required: ['scope', 'evidence'],
+        routes: { continue: 'audit-step', stop: '@stop' },
+    },
+    {
+        id: 'audit-step',
+        title: 'Independent Audit — reviewer relay',
+        stage: 'analyze',
+        block: 'review',
+        input: { brief: 'review.intake@v1' },
+        execution: { kind: 'relay', role: 'reviewer' },
+        protocol: 'review-audit@v1',
+        requestPath: 'reports/relay/review.request.json',
+        receiptPath: 'reports/relay/review.receipt.txt',
+        resultPath: 'stages/analyze/review-raw-findings.json',
+        pass: ['NO_ISSUES_FOUND', 'ISSUES_FOUND'],
+        skillSlots: [
+            {
+                id: 'review-independent-audit',
+                description: 'A skill for independently auditing code or a change for correctness, regressions, and scope creep.',
+            },
+        ],
+        routes: { continue: 'verdict-step', retry: 'audit-step', stop: '@stop' },
+    },
+    {
+        id: 'verdict-step',
+        title: 'Verdict — emit review.result',
+        stage: 'close',
+        block: 'close-with-evidence',
+        input: { brief: 'review.intake@v1', review: 'review.verdict@v1' },
+        output: 'review.result@v1',
+        execution: { kind: 'compose' },
+        protocol: 'review-verdict@v1',
+        reportPath: 'reports/review-result.json',
+        required: ['scope', 'findings', 'verdict'],
+        routes: { complete: '@complete', stop: '@stop' },
+    },
+];
+const reviewStageLabels = {
+    frame: { id: 'intake-stage', title: 'Intake' },
+    analyze: { id: 'audit-stage', title: 'Independent Audit' },
+    close: { id: 'verdict-stage', title: 'Verdict' },
+};
+export const reviewAssemblySpec = {
+    id: 'review',
+    title: 'Review Schematic',
+    purpose: 'Review flow: frame the audit scope, relay independent review to a reviewer, and close with a verdict report. The schematic uses a compact Intake, Independent Audit, and Verdict shape because Review is audit-only and does not implement or verify a change.',
+    status: 'active',
+    version: '0.1.0',
+    initial_contracts: ['task.intake@v1', 'route.decision@v1'],
+    contract_aliases: [
+        { generic: 'flow.brief@v1', actual: 'review.intake@v1' },
+        { generic: 'review.verdict@v1', actual: 'review.verdict@v1' },
+        { generic: 'flow.result@v1', actual: 'review.result@v1' },
+    ],
+    axes: {
+        allowed_depths: ['medium'],
+        supports_tournament: false,
+        supports_autonomous: false,
+        default: { depth: 'medium', tournament: false, tournament_n: 3, autonomous: false },
+    },
+    // Review DECLARES the terminal-outcome bind on its schematic; the compiler
+    // propagates it to the compiled manifest and the engine reads it through
+    // `resolveEngineFlags`. This is what makes an honest ISSUES_FOUND verdict
+    // (which the verdict step writes as review.result.outcome = 'stopped') bind
+    // the run's terminal outcome to 'stopped' rather than a green 'complete'.
+    engine_flags: {
+        binds_terminal_outcome_to_primary_result: true,
+    },
+    items: reviewBlockItems,
+    stageLabels: reviewStageLabels,
+    stagePathRationale: REVIEW_STAGE_PATH_RATIONALE,
+};
+//# sourceMappingURL=assembly-spec.js.map

package/dist/flows/review/assembly-spec.js.map

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