Agentic DAG architecture workflow

You must act as the monitor for this workflow regardless of which model is active. The monitor is the deterministic supervisor and state machine governing the development lifecycle. The monitor never authors private C++ implementations or edits public contracts directly. Instead, the monitor coordinates the pipeline, delegates creation to strategic and tactical workers, and gates progress using independent verifiers.

Step 1. Verify clean Git state and dispatch strategic worker for triage

Run the manifest introspection with a clean working tree requirement before starting.

python3 .agents/skills/architect/scripts/sync_manifest.py --require-clean-git

• If the script exits non zero, refuse to proceed until all uncommitted files are committed or stashed.
• The monitor never analyzes defect root causes or inspects private implementations directly. When user defect feedback arrives, ticket URLs are provided, or requirements change, evaluate complexity and select the strategic_worker model tier (pro for complex defects or DAG mutations, flash for scoped anomalies).
• If an issue tracking ticket URL is provided, retrieve ticket descriptions or reproduction steps before delegating triage to strategic_worker.
• Dispatch strategic_worker with the defect report to investigate root causes, trace component data flows, determine whether public contracts or the DAG require modification, and produce an explicit tactical remediation plan with testability guidance.
• Review cmake/dependencies.cmake and manifest.json before delegating work.
• Inspect advisory telemetry notes under refactor_candidates in manifest.json. Pass relevant topology and contract insulation hints to the strategic worker so they are weighed against new requirements using deterministic net_gain and free rider neighborhood discounts.

Step 2. Dispatch strategic worker to partition capabilities and scaffold targets

Dispatch the strategic worker subagent to group capabilities into physical targets and author public contracts.

{
  "Subagents": [
    {
      "TypeName": "strategic_worker",
      "Role": "Strategic Architect",
      "Model": "pro",
      "Workspace": "inherit",
      "Prompt": "Translate requirements into physical targets under targets/ while weighing advisory refactor_candidates telemetry in production_artifacts/manifest.json. Fold positive net_gain refactors and free rider neighborhood optimizations into the topology. Scaffold target directories, author public headers in targets/<name>/<name>/<name>.hpp, author error catalogs in targets/<name>/<name>.catalog, configure targets/<name>/CMakeLists.txt, verify stubbed builds under Clang_Custom_Debug, and run sync_manifest.py --check. Report completion back to monitor."
    }
  ]
}

The strategic worker enforces five hard invariant gates:

• Quotient DAG acyclicity. The physical target dependency graph must remain strictly acyclic.
• Anchor preservation. Never merge foundational anchors such as journal, perf_scope, or journal_signal_adapter. Keep the app executable target isolated from library anchors.
• Execution and verification parity. Never merge pure compute capabilities with stateful OS or I/O boundary capabilities. Pure compute targets must include benchmark suites.
• Compiler regime homogeneity. Capabilities requiring custom flags must remain isolated. Keep targets requiring -fno-fast-math or explicit SIMD flags separated from standard targets.
• Context locality and tactical helpers. Keep total worker context within $B_{\max} = 16384$ tokens. Single consumer helpers sharing the same compiler regime belong in private helper files inside the parent target.

Step 3. Audit contract anchor with strategic verifier and commit

Once the strategic worker finishes, verify the public contracts before committing the anchor.

1. Dispatch the strategic verifier subagent via invoke_subagent.

{
  "Subagents": [
    {
      "TypeName": "strategic_verifier",
      "Role": "Strategic Verifier",
      "Model": "flash",
      "Workspace": "inherit",
      "Prompt": "Audit candidate public contracts and manifest gates. Verify that targets/<name>/<name>/<name>.hpp headers have zero quoted includes and zero third-party header leakage. Verify that python3 .agents/skills/architect/scripts/sync_manifest.py --check passes gates H1 through H5. Report a concise pass or fail verdict."
    }
  ]
}

2. If the strategic verifier reports contract violations or gate failures, re-dispatch strategic_worker with the audit findings.
3. Once the strategic verifier reports a clean pass, the monitor commits the contract anchor commit to the repository.

Step 4. Orchestrate tactical workers and verifiers in parallel

Keep the monitor context free of private .cpp implementations and mechanical compiler loops.

1. Ensure tactical_worker and tactical_verifier are registered.
2. Dispatch parallel waves of tactical workers using invoke_subagent with Workspace set to "share". Set Model from subagent_model in manifest.json using flash for $\Psi(C_i) < 0.70$ and pro for $\Psi(C_i) \ge 0.70$.

{
  "Subagents": [
    {
      "TypeName": "tactical_worker",
      "Role": "Component Implementer",
      "Model": "flash",
      "Workspace": "share",
      "Prompt": "Implement targets/<name>/<name>.cpp against targets/<name>/<name>/<name>.hpp and direct upstream headers. Verify unit tests, sanitizers, and baseline benchmark."
    }
  ]
}

3. Restrict each tactical worker to reading and editing its assigned targets/<name>/ directory plus reading public upstream headers.
4. When a tactical worker finishes, dispatch tactical_verifier via invoke_subagent with Workspace set to "inherit" and Model set to "flash" to audit the candidate diff.
5. If tactical_verifier reports a clean pass, commit the component changes. If it detects test dilution or invariant evasion, discard the changes and dispatch a fresh worker with the audit findings.

Step 5. Whole graph verification and final release gate

Once all components merge cleanly, verify the integrated system across compilers and synchronize manifest.json.

./production_artifacts/build_all.sh custom debug
./production_artifacts/build_all.sh default release
python3 .agents/skills/architect/scripts/sync_manifest.py --check

Dispatch strategic_verifier via invoke_subagent to confirm all five invariant gates $H_1$ through $H_5$ pass and zero dirty benchmarks remain.

If an issue tracking ticket URL was provided with update instructions, post a completion summary with root cause findings, commit references, and benchmark diffs back to the tracking system.