@smartmemory/compose 0.3.7 → 0.4.0

package/pipelines/content.stratum.yaml

@@ -6,7 +6,7 @@
 #   steps: 4
 #   estimated_minutes: 20
 
-version: "0.1"
+version: 1
 
 # content pipeline
 #
@@ -16,97 +16,101 @@ version: "0.1"
 #   3. review    — review for accuracy, completeness, and clarity
 #   4. publish   — finalize and commit
 #
-# Inputs:
-#   task — what to write (doc type, topic, target audience)
+# COMP-PIPELINE-QUARANTINE: re-authored from v0.1 to TS v1. Linear chain, no
+# gates or backward routing. `retries: N` -> `attempts: N + 1` (v0.1 counted
+# retries AFTER the first try). The `outcome` enum moved into the contract.
+# review's fix loop is its own `attempts` budget: `ensure` rejects an unclean
+# review and the engine re-runs the step with the findings as feedback.
 #
-# Usage:
-#   stratum_plan <this yaml> "content" {"task": "..."}
+#
+# COMP-PIPELINE-QUARANTINE round 2: the flow input is the RUNNER's envelope, not
+# a bespoke `task`. runBuild derives plan inputs from the MODE, not from the spec
+# (lib/build.js startFresh), and feature mode always sends
+# {featureCode, description, implementer_agent, reviewer_agent} plus an optional
+# pre_merge_gate. Declaring `task` meant this spec resolved but could never plan —
+# making it reachable via `--template` without this change just moved the failure
+# from "not found" to a failed run. `${input.description}` carries what `task` did.
+# Inputs (the runner's feature envelope):
+#   featureCode  — the feature/work code
+#   description  — what to do; this is what the old `task` input carried
 
 contracts:
   ContentResult:
-    phase:    {type: string}
-    artifact: {type: string}
-    summary:  {type: string}
-    outcome:  {type: string, values: [complete, failed]}
+    phase: string
+    artifact: string
+    summary: string
+    outcome: complete|skipped|failed   # `skipped` is reachable: compose offers an interactive skip
 
+  # CANONICAL ReviewResult — STRAT-CLAUDE-EFFORT-PARITY. It MUST carry meta,
+  # lenses_run, auto_fixes and asks even though this pipeline never sets them by
+  # hand: compose enables review normalization for any step whose out contract is
+  # NAMED ReviewResult (deriveOrdinaryReviewScaffold), and the normalizer always
+  # stamps those four fields. Engine contracts are strict, so a narrower
+  # declaration makes every review step fail with unrecognized_keys and exhaust
+  # its attempts — the same defect class as COMP-SHIP-CONTRACT. Caught in review.
   ReviewResult:
-    clean:    {type: boolean}
-    summary:  {type: string}
-    findings: {type: array}
-
-functions:
-  research:
-    mode: compute
-    intent: >
-      Gather context for the content. Read existing documentation, related
-      code, and prior art. Identify gaps and outline key topics to cover.
-      Return a summary of research findings.
-    input:
-      task: {type: string}
-    output: ContentResult
-    retries: 1
-
-  draft:
-    mode: compute
-    intent: >
-      Write the content based on research findings. Follow existing
-      documentation conventions and standards. Write to the appropriate
-      file path. Return the artifact path.
-    input:
-      task: {type: string}
-    output: ContentResult
-    ensure:
-      - "result.outcome == 'complete'"
-    retries: 2
-
-  review:
-    mode: compute
-    intent: >
-      Review the drafted content for accuracy, completeness, and clarity.
-      Check that all claims are supported by code or documentation.
-      Return { "clean": boolean, "summary": string, "findings": string[] }.
-    input:
-      task: {type: string}
-    output: ReviewResult
-    ensure:
-      - "result.clean == true"
-    retries: 3
-
-  publish:
-    mode: compute
-    intent: >
-      Finalize the content. Update any cross-references (README, CHANGELOG,
-      index files). Commit with a descriptive message.
-    input:
-      task: {type: string}
-    output: ContentResult
-    retries: 1
+    clean: boolean
+    summary: string
+    findings: array
+    meta: object
+    lenses_run: string[]
+    auto_fixes: array
+    asks: array
 
 flows:
+  entry: content
   content:
     input:
-      task: {type: string}
-    output: ContentResult
+      featureCode: string
+      description: string
+      implementer_agent: string?
+      reviewer_agent: string?
+      pre_merge_gate: string[]?
+    output:
+      from: "${publish.output}"
+      contract: ContentResult
     steps:
       - id: research
-        function: research
-        inputs:
-          task: "$.input.task"
+        agent: claude
+        do: >
+          Gather context for this content: ${input.description}. Read existing
+          documentation, related code and prior art. Identify gaps and outline
+          the key topics to cover. Return a summary of research findings.
+        out: ContentResult
+        attempts: 2
 
       - id: draft
-        function: draft
-        inputs:
-          task: "$.input.task"
-        depends_on: [research]
+        after: [research]
+        agent: claude
+        do: >
+          Write the content for ${input.description} based on the research findings:
+          ${research.output.summary}. Follow existing documentation conventions
+          and standards. Write to the appropriate file path and return the
+          artifact path.
+        out: ContentResult
+        ensure:
+          - expr: "result.outcome == 'complete'"
+        attempts: 3
 
       - id: review
-        function: review
-        inputs:
-          task: "$.input.task"
-        depends_on: [draft]
+        after: [draft]
+        agent: claude
+        do: >
+          Review the drafted content at ${draft.output.artifact} for accuracy,
+          completeness and clarity. Check that every claim is supported by code
+          or documentation. If this is a retry, fix the previous findings before
+          re-reviewing. Return { "clean": boolean, "summary": string,
+          "findings": string[] }.
+        out: ReviewResult
+        ensure:
+          - expr: "result.clean == true"
+        attempts: 4
 
       - id: publish
-        function: publish
-        inputs:
-          task: "$.input.task"
-        depends_on: [review]
+        after: [review]
+        agent: claude
+        do: >
+          Finalize the content for ${input.description}. Update any cross-references
+          (README, CHANGELOG, index files). Commit with a descriptive message.
+        out: ContentResult
+        attempts: 2

package/pipelines/coverage-sweep.stratum.yaml

@@ -6,47 +6,66 @@
 #   steps: 1
 #   estimated_minutes: 10
 
-version: "0.1"
+version: 1
 
 # coverage-sweep pipeline
 #
-# Runs the test suite in a loop until all tests pass.
-# Same pattern as review-fix.stratum.yaml but for test coverage.
+# Runs the test suite until it passes. The loop is the step's own `attempts`
+# budget: `ensure` rejects a run with failures, the engine retries the step with
+# the previous failure as feedback, and the step only settles when the suite is
+# green. Same pattern as review-fix.stratum.yaml but for test coverage.
 #
-# Inputs:
-#   task — what to test (feature description, file paths, etc.)
+# COMP-PIPELINE-QUARANTINE: re-authored from v0.1 to TS v1. `retries: 15` became
+# `attempts: 16` — v0.1 counted retries AFTER the first try, so a bare rename
+# would have cost this pipeline a run.
 #
-# Usage:
-#   stratum_plan <this yaml> "coverage_sweep" {"task": "..."}
+# DELIBERATE BEHAVIOR CHANGE (owner decision, not a side effect of the dialect
+# move): the v0.1 prompt only RAN the suite and reported failures, so a retry
+# re-ran identical code and reported the identical failure up to fifteen times —
+# a loop that could not converge. The step now fixes what it finds before the
+# next attempt, which is what makes the retry budget meaningful. This makes the
+# pipeline write-capable, so it is no longer safe to treat as read-only.
+#
+#
+# COMP-PIPELINE-QUARANTINE round 2: the flow input is the RUNNER's envelope, not
+# a bespoke `task`. runBuild derives plan inputs from the MODE, not from the spec
+# (lib/build.js startFresh), and feature mode always sends
+# {featureCode, description, implementer_agent, reviewer_agent} plus an optional
+# pre_merge_gate. Declaring `task` meant this spec resolved but could never plan —
+# making it reachable via `--template` without this change just moved the failure
+# from "not found" to a failed run. `${input.description}` carries what `task` did.
+# Inputs (the runner's feature envelope):
+#   featureCode  — the feature/work code
+#   description  — what to do; this is what the old `task` input carried
 
 contracts:
   CoverageResult:
-    passing:  {type: boolean}
-    summary:  {type: string}
-    failures: {type: array}
-
-functions:
-  run_coverage:
-    mode: compute
-    intent: >
-      Run the project test suite. Return structured JSON:
-      { "passing": boolean, "summary": string, "failures": string[] }.
-      Set passing=true only if all tests pass with no failures.
-      If tests fail, list each failing test name in the failures array.
-    input:
-      task: {type: string}
-    output: CoverageResult
-    ensure:
-      - "result.passing == true"
-    retries: 15
+    passing: boolean
+    summary: string
+    failures: string[]
 
 flows:
+  entry: coverage_sweep
   coverage_sweep:
     input:
-      task: {type: string}
-    output: CoverageResult
+      featureCode: string
+      description: string
+      implementer_agent: string?
+      reviewer_agent: string?
+      pre_merge_gate: string[]?
+    output:
+      from: "${sweep.output}"
+      contract: CoverageResult
     steps:
       - id: sweep
-        function: run_coverage
-        inputs:
-          task: "$.input.task"
+        agent: claude
+        do: >
+          Run the project test suite for ${input.description}. Return structured JSON:
+          { "passing": boolean, "summary": string, "failures": string[] }.
+          Set passing=true only if all tests pass with no failures.
+          If tests fail, list each failing test name in the failures array and
+          fix them before the next attempt.
+        out: CoverageResult
+        ensure:
+          - expr: "result.passing == true"
+        attempts: 16

package/pipelines/plan.stratum.yaml

@@ -1,4 +1,4 @@
-version: "0.3"
+version: 1
 
 # COMP-ROADMAP-PLAN — the `plan` product-planning lifecycle (peer to build/fix).
 # Front half of goal-to-product: frame → research → ideate → converge → estimate
@@ -8,95 +8,93 @@ version: "0.3"
 # planInputs envelope (lib/lifecycle-modes.js plan.runner.planInputs == 'plan').
 # Absorbs `compose new`: ideation routes to the ideabox, output is canonical
 # feature.json (not hand-authored ROADMAP rows or design.md-only seeds).
-
-workflow:
-  name: plan
-  description: "Product-planning lifecycle — frame, research, ideate, converge to build-ready feature specs"
-  input:
-    projectName:
-      type: string
-      required: true
-    intent:
-      type: string
-      required: true
+#
+# COMP-PIPELINE-QUARANTINE: re-authored from v0.3 to TS v1, which is what makes
+# `compose plan` runnable again — it had been dead since the STRAT-PY-RETIRE
+# cutover, and was edited on 2026-08-05 while already unrunnable.
+#   - The `workflow:` header and the `functions:` gate declarations are gone; v1
+#     declares flow input on the flow and gates inline as `gate:` blocks. The
+#     approve/revise/kill routing is carried over unchanged, including the
+#     backward `on_revise` edges, which v1 gates express natively.
+#   - Interpolation moves from single-brace `{intent}` to `${input.intent}`, and
+#     step references from `$.steps.plan.output.created` to `${plan.output.created}`.
+#     The `{{...}}` escape the old templater needed for literal JSON braces is no
+#     longer required, so those are plain braces now.
+#   - `retries: N` -> `attempts: N + 1` (v0.3 counted retries AFTER the first try).
 
 contracts:
   PlanDesignResult:
-    artifact:   {type: string}
-    features:   {type: array}
-    summary:    {type: string}
+    artifact: string
+    features: string[]
+    summary: string
 
   PlanConvergeResult:
-    artifact:   {type: string}
-    created:    {type: array}
-    summary:    {type: string}
+    artifact: string
+    created: string[]
+    summary: string
 
   PlanHandoffResult:
-    handed_off: {type: array}
-    summary:    {type: string}
-
-functions:
-  plan_design_gate:
-    mode: gate
-    timeout: 7200
-
-  plan_converge_gate:
-    mode: gate
-    timeout: 7200
+    handed_off: string[]
+    summary: string
 
 flows:
+  entry: plan
   plan:
     input:
-      projectName: {type: string}
-      intent: {type: string}
-    output: PlanHandoffResult
+      projectName: string
+      intent: string
+    output:
+      from: "${ship.output}"
+      contract: PlanHandoffResult
+    max_rounds: 10
     steps:
       # Phase: explore_design — frame, research, ideate
       - id: explore_design
         agent: claude
-        intent: >
-          You are running the PRODUCT-PLANNING front half for this intent: {intent}
+        do: >
+          You are running the PRODUCT-PLANNING front half for this intent:
+          ${input.intent}
 
-          Do three things, then write the result to docs/plans/{projectName}/design.md:
+          Do three things, then write the result to
+          docs/plans/${input.projectName}/design.md:
           1. FRAME — restate the goal, the problem it solves, who it is for, and the
              scope boundaries (what is in v1, what is explicitly out).
           2. RESEARCH — search the web and the codebase for prior art, existing
              tools, architectural patterns, and risks. Summarize what is relevant.
           3. IDEATE — propose candidate features (each with a short code and a
-             one-line description, ordered by dependency). Capture each idea in the
-             ideabox funnel (append to docs/product/ideabox.md, or run
-             `compose ideabox add`) so ideation lives in the funnel, not here. Then
-             shortlist the features you recommend building first.
-
-          Write docs/plans/{projectName}/design.md containing FRAME, RESEARCH, and
-          the shortlist (with feature codes). Return its path in "artifact" and the
+             one-line description, ordered by dependency). Capture each idea with
+             `compose ideabox add "<title>" [--desc ...] [--cluster ...]` so ideation
+             lives in the funnel, not here. Do NOT edit docs/product/ideabox.md
+             directly: it is generated output now, and an edit to it is discarded by
+             the next render. Then shortlist the features you recommend building first.
+
+          Write docs/plans/${input.projectName}/design.md containing FRAME, RESEARCH,
+          and the shortlist (with feature codes). Return its path in "artifact" and the
           shortlisted feature codes in "features".
-        inputs:
-          projectName: "$.input.projectName"
-          intent: "$.input.intent"
-        output_contract: PlanDesignResult
+        out: PlanDesignResult
         ensure:
-          - "file_exists(result.artifact)"
-          - "len(result.features) > 0"
-        retries: 2
+          - expr: "file_exists(result.artifact)"
+          - expr: "len(result.features) > 0"
+        attempts: 3
 
       # Gate: human reviews the framing + research + shortlist
       - id: plan_design_gate
-        function: plan_design_gate
-        on_approve: plan
-        on_revise: explore_design
-        on_kill: null
-        depends_on: [explore_design]
+        after: [explore_design]
+        gate:
+          on_approve: plan
+          on_revise: explore_design
+          on_kill: null
 
       # Phase: plan — converge, estimate, write build-ready specs
       - id: plan
+        after: [plan_design_gate]
         agent: claude
-        intent: >
-          Converge the shortlist in docs/plans/{projectName}/design.md into
+        do: >
+          Converge the shortlist in docs/plans/${input.projectName}/design.md into
           build-ready feature specs. For EACH feature you commit to building:
           1. ESTIMATE — assign a complexity (S | M | L | XL) and a triage build
              profile (which lifecycle phases it needs, e.g.
-             {{"needs_prd": false, "needs_architecture": false}}).
+             {"needs_prd": false, "needs_architecture": false}).
           2. SPEC — first write the per-feature design to <CODE>/design.md inside the
              project features dir (docs/features/<CODE>/design.md by default, or the
              paths.features root in .compose/compose.json). This is a real
@@ -109,53 +107,45 @@ flows:
                compose roadmap add <CODE> --description "<one-line>" --phase "<phase>" \
                  --status PLANNED --complexity <S|M|L|XL> \
                  --profile '{"needs_prd":<bool>,"needs_architecture":<bool>,"needs_verification":<bool>,"needs_report":<bool>}' \
-                 --planned-by "{projectName}" [--impact <low|medium|high>]
+                 --planned-by "${input.projectName}" [--impact <low|medium|high>]
 
              Write design.md BEFORE running it (the command verifies design.md exists
              and refuses otherwise). Do NOT hand-author ROADMAP rows or write
              feature.json by hand.
 
           Then write the planning narrative (decisions, estimates, sequencing) to
-          docs/plans/{projectName}/plan.md. Return plan.md in "artifact" and the
+          docs/plans/${input.projectName}/plan.md. Return plan.md in "artifact" and the
           created feature codes in "created".
-        inputs:
-          projectName: "$.input.projectName"
-          intent: "$.input.intent"
-        output_contract: PlanConvergeResult
+        out: PlanConvergeResult
         ensure:
-          - "file_exists(result.artifact)"
-          - "len(result.created) > 0"
-        retries: 2
-        depends_on: [plan_design_gate]
+          - expr: "file_exists(result.artifact)"
+          - expr: "len(result.created) > 0"
+        attempts: 3
 
       # Gate: human approves the converged plan + build-ready specs
       - id: plan_converge_gate
-        function: plan_converge_gate
-        on_approve: ship
-        on_revise: plan
-        on_kill: null
-        depends_on: [plan]
+        after: [plan]
+        gate:
+          on_approve: ship
+          on_revise: plan
+          on_kill: null
 
       # Phase: ship — handoff / verify build-readiness (plan mode does NOT git-commit
       # here; runBuild's ship interception is gated off for mode=plan).
       - id: ship
+        after: [plan_converge_gate]
         agent: claude
-        intent: >
-          Finalize the plan→build handoff. For EACH feature code in the provided
-          "created" list (the features the plan phase produced), verify its folder
-          under the project features dir (docs/features/<CODE>/ by default, or the
-          paths.features root in .compose/compose.json) has a feature.json (status
-          PLANNED, with plannedBy "{projectName}", complexity, profile,
+        do: >
+          Finalize the plan-to-build handoff. For EACH feature code in
+          ${plan.output.created} (the features the plan phase produced), verify its
+          folder under the project features dir (docs/features/<CODE>/ by default, or
+          the paths.features root in .compose/compose.json) has a feature.json (status
+          PLANNED, with plannedBy "${input.projectName}", complexity, profile,
           triageTimestamp) and a design.md. Produce a short handoff summary listing
           each build-ready feature and the exact `compose build <CODE>` command to
           start it. Do NOT git-commit here — just verify and summarize. Return the
           verified feature codes in "handed_off".
-        inputs:
-          projectName: "$.input.projectName"
-          intent: "$.input.intent"
-          created: "$.steps.plan.output.created"
-        output_contract: PlanHandoffResult
+        out: PlanHandoffResult
         ensure:
-          - "len(result.handed_off) > 0"
-        retries: 1
-        depends_on: [plan_converge_gate]
+          - expr: "len(result.handed_off) > 0"
+        attempts: 2