@dtlabs/ai-toolkit 0.6.0 → 0.8.0

package/.claude/workflows/pm-phase3.js

@@ -4,6 +4,7 @@ export const meta = {
   phases: [
     { title: 'Parse',          detail: 'Parse Work Breakdown into structured implementation phases' },
     { title: 'Implementation', detail: 'Dispatch developer agents per US, review, commit' },
+    { title: 'Test',           detail: 'Single test run after all phases complete' },
     { title: 'Remediation',    detail: 'Fix OPEN issues from Issues Register' },
     { title: 'PR',             detail: 'Push branch, create PR, update registry' },
     { title: 'Actuals',        detail: 'Write Token-Estimate and Effort-Estimate actuals' },
@@ -237,6 +238,16 @@ const executePhase = async (implPhase) => {
   }
 
   phasesDone++
+
+  // Persist the cumulative token ledger to disk after every completed phase.
+  // budget.spent() is an in-memory counter — if the workflow is stopped (manual
+  // stop, crash, timeout) before the Actuals phase, all token data would be lost.
+  // Writing the full ledger here means the file always reflects real consumption
+  // up to the last completed phase, recoverable manually or by a resumed run.
+  await agent(
+    `Write the following JSON to ${featureDir}/${prefix}-token-ledger.json (overwrite the file if it exists):\n${JSON.stringify(tokenLedger, null, 2)}`,
+    { label: `persist-ledger:${implPhase.phase_id}`, phase: 'Implementation', model: 'haiku' }
+  )
 }
 
 // Execute waves: phases in the same wave run in parallel, waves are sequential
@@ -267,6 +278,28 @@ issuesPath = issuesResult?.path || ''
 issuesOpen = issuesResult?.open_count || 0
 log(`Implementation complete — ${phasesDone} phases, ${usPassed.length} US passed, ${usEscalated.length} escalated, ${issuesOpen} open issues`)
 
+// ── Final test run ────────────────────────────────────────────────────────────
+// Developer agents no longer run the test suite themselves (they do a syntax-check
+// build at most). Running the suite once here, after all files are written, replaces
+// N parallel per-agent test runs — cutting ~1h of duplicated builds and artifact
+// contention down to a single centralized run with one consolidated failure report.
+phase('Test')
+
+const beforeTest = budget.spent()
+await agent(
+  `Run the full test suite in the repository root and report the result.
+
+1. Read AGENTS.md in the repository root to find the exact test command for this project.
+2. Run that command (e.g. \`dotnet test --no-restore --logger "console;verbosity=normal"\`, \`npm test\`).
+3. Report the outcome: total passed/failed, and for any failures the test name and first error line.
+
+Do NOT fix failing tests — only report them.`,
+  { label: 'final-test-run', phase: 'Test', model: 'haiku' }
+)
+const testTokens = budget.spent() - beforeTest
+tokenLedger.push({ agent: 'final-test-run', model: 'haiku', phase_delta_tokens: testTokens })
+log(`Test run complete — ${testTokens} tokens`)
+
 // ── Remediation ───────────────────────────────────────────────────────────────
 phase('Remediation')
 
@@ -381,8 +414,77 @@ log(`PR done: ${prResult.pr_url} — ${prTokens} tokens`)
 // ── Actuals ───────────────────────────────────────────────────────────────────
 phase('Actuals')
 
+// Fallback: merge in any ledger entries that were persisted to disk but are missing
+// from the in-memory ledger (e.g. this is a resumed run and earlier phases ran in a
+// previous, interrupted invocation). The in-memory ledger has priority for entries
+// present in both — it reflects the most recent measurements.
+const persistedLedgerRaw = await agent(
+  `Read ${featureDir}/${prefix}-token-ledger.json and return its contents as a raw JSON string, nothing else. If the file does not exist, return exactly "[]".`,
+  { label: 'read-ledger', phase: 'Actuals', model: 'haiku' }
+)
+try {
+  const persisted = JSON.parse(typeof persistedLedgerRaw === 'string' ? persistedLedgerRaw.trim() : '[]')
+  if (Array.isArray(persisted)) {
+    const inMemoryByAgent = new Map(tokenLedger.map((e, i) => [e.agent, i]))
+    for (const entry of persisted) {
+      if (!entry || !entry.agent) continue
+      const idx = inMemoryByAgent.get(entry.agent)
+      if (idx === undefined) {
+        // entry exists on disk but not in memory — recover it (e.g. from a prior interrupted run)
+        tokenLedger.push(entry)
+        inMemoryByAgent.set(entry.agent, tokenLedger.length - 1)
+        log(`Recovered ledger entry from disk: ${entry.agent} (${entry.phase_delta_tokens} tokens)`)
+      } else if (tokenLedger[idx].phase_delta_tokens === 0 && (entry.phase_delta_tokens || 0) > 0) {
+        // in-memory entry has delta=0 (cached agent on resume) but disk has real data — prefer disk
+        tokenLedger[idx] = entry
+        log(`Restored real token count from disk: ${entry.agent} (${entry.phase_delta_tokens} tokens)`)
+      }
+    }
+  }
+} catch (e) {
+  log(`Could not parse persisted token ledger — using in-memory ledger only`)
+}
+
 const totalPhase3Tokens = tokenLedger.reduce((s, e) => s + (e.phase_delta_tokens || 0), 0)
 
+// ── Load token pricing for cost columns ──────────────────────────────────────
+const pricingRaw3 = await agent(
+  `Read the file docs/token-pricing.json and return its raw JSON contents as a string, nothing else.`,
+  { label: 'read-pricing', phase: 'Actuals', model: 'haiku' }
+)
+let pricing3 = null
+try { pricing3 = JSON.parse(typeof pricingRaw3 === 'string' ? pricingRaw3.trim() : '{}') } catch (_) {}
+
+function tokenCostEur3(tokens, model) {
+  if (!pricing3 || !pricing3.models) return null
+  const m = pricing3.models[model] || pricing3.models['sonnet']
+  const usdPer1M = 0.8 * m.input_per_1m_usd + 0.2 * m.output_per_1m_usd
+  return (tokens * usdPer1M / 1_000_000) * (pricing3.usd_to_eur || 1)
+}
+
+function formatEur3(val) {
+  if (val === null || val === undefined) return '—'
+  return '€' + val.toFixed(4)
+}
+
+// Aggregate the per-agent ledger into per-role totals so the actuals line up with the
+// per-role estimate rows pm-phase2 wrote (developer-backend, developer-testing,
+// review-solution, pr-and-registry, write-actuals, plus final-test-run). Precomputing
+// here keeps the write-actuals agent from having to reason about grouping.
+const roleTotals = {}
+const roleModels = {}
+for (const e of tokenLedger) {
+  const role = String(e.agent).split(':')[0]
+  roleTotals[role] = (roleTotals[role] || 0) + (e.phase_delta_tokens || 0)
+  roleModels[role] = e.model || 'sonnet'
+}
+const roleRows = Object.entries(roleTotals)
+  .map(([role, tok]) => `| ${role} | ${tok} | ${formatEur3(tokenCostEur3(tok, roleModels[role]))} |`)
+  .join('\n')
+const totalPhase3CostEur = formatEur3(
+  Object.entries(roleTotals).reduce((s, [role, tok]) => s + (tokenCostEur3(tok, roleModels[role]) || 0), 0)
+)
+
 const ACTUALS_SCHEMA = {
   type: 'object',
   properties: {
@@ -405,30 +507,50 @@ ${JSON.stringify(tokenLedger, null, 2)}
 
 Total tokens consumed by pm-phase3 workflow: ${totalPhase3Tokens} (exact, from budget tracking)
 
-TASK 1 — Append actuals to ${prefix}-Token-Estimate.md:
-Find the file in the feature directory. If it does not exist, create it.
+TASK 1 — Fill in the Phase 3 actuals in ${prefix}-Token-Estimate.md IN PLACE.
+Read the file in the feature directory first (it was written by pm-phase2 and already contains
+Phase 1/Phase 2 actuals and the Phase 3 estimate table). If it does not exist, create it.
 
-Append this section at the end of the file:
+Do NOT append a second Phase 3 table. Instead:
 
----
+1. Locate the existing "## Phase 3 — Implementation (Estimates)" section. Replace its heading
+   with "## Phase 3 — Implementation (Est. vs Actual, by role)" and REPLACE its table with the
+   per-role reconciliation below — filling the "Tokens Actual" and "Actual cost €" columns of the
+   existing per-role estimate rows (keep the existing Tokens Est. and Est. cost € values; add a Delta column):
+
+| Role | Model | Tokens Actual | Actual cost € |
+|------|-------|--------------|--------------|
+${roleRows}
+| **Phase 3 total** | | **${totalPhase3Tokens}** | **${totalPhase3CostEur}** |
 
-## Phase 3 — Implementation (Actuals)
+   Match each existing estimate row (developer-backend, developer-testing, review-solution,
+   remediation, pr-and-registry, write-actuals) to the actual role total above by name, write the
+   actual into its "Tokens Actual" and "Actual cost €" cells, and compute Delta = Actual − Est (tokens).
+   Roles present in the actuals but absent from the estimate rows (e.g. final-test-run) get a new row with Est. = —.
 
-> Phase totals are exact measurements from budget tracking.
-> Per-agent values are exact where each agent ran separately; proportional where merged.
+2. Immediately after that table, add the per-agent detail as a sub-table (source of truth):
 
-| Agent | Phase | Model | Tokens Est. | Tokens Actual |
-|-------|-------|-------|------------|--------------|
-${tokenLedger.map(e => `| ${e.agent} | — | ${e.model} | — | ${e.phase_delta_tokens} |`).join('\n')}
-| **Phase 3 total** | | | **—** | **${totalPhase3Tokens}** |
+### Phase 3 — per-agent detail (actuals)
 
-## Grand Total (updated)
+| Agent | Model | Tokens Actual | Actual cost € |
+|-------|-------|--------------|--------------|
+${tokenLedger.map(e => `| ${e.agent} | ${e.model} | ${e.phase_delta_tokens} | ${formatEur3(tokenCostEur3(e.phase_delta_tokens, e.model))} |`).join('\n')}
+| **Detail total** | | **${totalPhase3Tokens}** | **${totalPhase3CostEur}** |
 
-| Phase | Tokens Est. | Tokens Actual |
-|-------|------------|--------------|
-| Phase 1 — Documentation | — | *(see above)* |
-| Phase 2 — Work Breakdown | — | *(see above)* |
-| Phase 3 — Implementation | *(see above)* | ${totalPhase3Tokens} |
+3. Update the existing "## Grand Total" table. Read the Phase 1 and Phase 2 actual totals from
+   the top of THIS SAME file (the "Phase 1 total" and "Phase 2 total" rows already present) and
+   copy them verbatim — never the literal text "(see above)". If a value there is "—" (Phase 1 is
+   written as a placeholder by pm-phase2 and filled later by the orchestrator), keep it as "—";
+   do NOT invent a number. The table must read:
+
+| Phase | Tokens Est. | Est. cost € | Tokens Actual | Actual cost € | Delta (tokens) |
+|-------|------------|------------|--------------|--------------|---------------|
+| Phase 1 — Documentation | — | — | {Phase 1 total from this file, or — if placeholder} | — | — |
+| Phase 2 — Work Breakdown | — | — | {Phase 2 total from this file} | {Phase 2 cost from this file} | — |
+| Phase 3 — Implementation | {existing Phase 3 estimate total} | {existing Phase 3 est. cost} | ${totalPhase3Tokens} | ${totalPhase3CostEur} | {Actual − Est} |
+| **Total** | **{sum of numeric Est}** | **{sum of numeric Est. cost}** | **{sum of numeric Actual}** | **{sum of numeric Actual cost}** | **{Actual − Est}** |
+
+4. Append (or update if present) the Implementation Summary section:
 
 ## Implementation Summary
 
@@ -438,6 +560,8 @@ ${tokenLedger.map(e => `| ${e.agent} | — | ${e.model} | — | ${e.phase_delta_
 | US passed | ${usPassed.join(', ') || 'N/A'} |
 | US escalated | ${usEscalated.join(', ') || 'none'} |
 
+Remove the stale "*Actuals will be appended by pm-phase3...*" footer line if it is still present.
+
 TASK 2 — Update actuals in ${prefix}-Effort-Estimate.md:
 Find the file in the feature directory. Read the existing Per-Phase Breakdown table and update the "Actual Agent" column for each phase that was implemented. Use the token ledger to infer which phases completed:
 - Phases in usPassed: ${usPassed.join(', ') || 'none'} — mark Actual Agent as completed (write the wall-clock duration if available, otherwise write "done (agent)")
@@ -501,6 +625,17 @@ ${phase3Events}`,
   { label: 'finalize-process-log', phase: 'Actuals' }
 )
 
+await agent(
+  `Commit the actuals files for this feature delivery run.
+
+Run these exact git commands in the repository root:
+  git add "${featureDir3}/${prefix}-Token-Estimate.md" "${featureDir3}/${prefix}-Effort-Estimate.md" "${featureDir3}/${prefix}-process-log.txt"
+  git commit -m "docs(${prefix}): add token/effort actuals and process log"
+
+If there is nothing to commit (all files already committed), that is fine — report success.`,
+  { label: 'commit-actuals', phase: 'Actuals' }
+)
+
 return {
   pr_url:       prResult.pr_url,
   token_ledger: tokenLedger,

package/CHANGELOG.md

@@ -1,4 +1,55 @@
 ## 0.1.4 (2026-07-21)
+## [0.8.0](https://github.com/dtlab-tech/ai-toolkit/compare/v0.7.0...v0.8.0) (2026-08-04)
+
+
+### Features
+
+* **FTR-011:** implement shared infrastructure (INFRA) ([718b0eb](https://github.com/dtlab-tech/ai-toolkit/commit/718b0ebe684814028b0457351a40b171ea80a197))
+* **FTR-011:** implement US-01 — Implement readManifest() Function ([aad7de1](https://github.com/dtlab-tech/ai-toolkit/commit/aad7de19aa6aaf48578c46eebd3bb236ebb4fadb))
+* **FTR-011:** implement US-02 — Implement computeOrphans() Function ([3a70517](https://github.com/dtlab-tech/ai-toolkit/commit/3a705173e649aa7782d036b5790c830c88a1d797))
+* **FTR-011:** implement US-03 — Implement moveToTrash() Function ([a6ac7d2](https://github.com/dtlab-tech/ai-toolkit/commit/a6ac7d2d841905bba24f5349a7d763c9f43527e8))
+* **FTR-011:** implement US-04 — Implement writeManifest() Function ([dc43ea1](https://github.com/dtlab-tech/ai-toolkit/commit/dc43ea1e35c2e4981876ad5f46b3138890851fcd))
+* **FTR-011:** implement US-05 — Integrate Prune Phase into runInstall() and Add UI Display ([bca87ea](https://github.com/dtlab-tech/ai-toolkit/commit/bca87ea8f8843f6a8a07371eaef072b1fc004453))
+* **FTR-011:** implement US-06 — Add CI Safety Net — Agent Name-to-Filename Alignment Check ([06db318](https://github.com/dtlab-tech/ai-toolkit/commit/06db3180b4867b611a2793bf2c74e8510e66827c))
+* **FTR-011:** Installer Manifest and Orphan Pruning ([764eff4](https://github.com/dtlab-tech/ai-toolkit/commit/764eff4dd3b13ee34e7e4be7159c08168e49fe1d))
+* **FTR-011:** update effort and token estimates, add implementation summary, and log completion details ([ce5660d](https://github.com/dtlab-tech/ai-toolkit/commit/ce5660dec691b75bb501bcadb149c2f4eaabdb5a))
+* **FTR-012:** implement shared infrastructure (INFRA) ([da14ae1](https://github.com/dtlab-tech/ai-toolkit/commit/da14ae15d19301c47231e73872ecba75f180e739))
+* **FTR-012:** implement US-01 — Fresh Installation with Allowlist Opt-In ([803018a](https://github.com/dtlab-tech/ai-toolkit/commit/803018aafe77abb06390849540f7fb214fccbc40))
+* **FTR-012:** implement US-02 — Merge Allowlist into Existing Settings ([9855abc](https://github.com/dtlab-tech/ai-toolkit/commit/9855abc940443d4e75b7a1b3340715d8e1403fcf))
+* **FTR-012:** implement US-03 — Ask-Beats-Allow Conflict Resolution ([9c51984](https://github.com/dtlab-tech/ai-toolkit/commit/9c5198490824647bac7b1850b09e624d9f00e883))
+* **FTR-012:** implement US-04 — Reinstall with Idempotent Merge ([8e9a49f](https://github.com/dtlab-tech/ai-toolkit/commit/8e9a49f69d7bb761a698b2ac7f7a405d5d2d833e))
+* **FTR-012:** implement US-05 — .gitignore Creation and Idempotent Update ([20e19de](https://github.com/dtlab-tech/ai-toolkit/commit/20e19de3c38cbbfcd5dd27c8b8b5ab629036b101))
+* **FTR-012:** Installer Bash Allowlist ([2deb73e](https://github.com/dtlab-tech/ai-toolkit/commit/2deb73ef4ad4189c6eea1ae46ec0f0dc6ece469e))
+* **FTR-012:** mark feature as completed in registry ([ab90d58](https://github.com/dtlab-tech/ai-toolkit/commit/ab90d5878a4091ccaef38863c14634ebd2082623))
+* **FTR-013:** add additional agent entries for US-03 and US-04 in ledger ([6f756ed](https://github.com/dtlab-tech/ai-toolkit/commit/6f756edfaa0d75b48809aa3964261efa65fd69f9))
+* **FTR-013:** add registry entry and update ledger actuals ([23f5138](https://github.com/dtlab-tech/ai-toolkit/commit/23f513801486c36e95782ea513e15fcfcb755d06))
+* **FTR-013:** implement shared infrastructure (INFRA) ([99d564f](https://github.com/dtlab-tech/ai-toolkit/commit/99d564f8ca543b7cd95c5cf1a5687961ef402921))
+* **FTR-013:** implement US-01 — Initialize and Track Ledger in define-feature Agent ([ce0b010](https://github.com/dtlab-tech/ai-toolkit/commit/ce0b010afd40e94f9e9e2618eca1fbcc60ede7ae))
+* **FTR-013:** implement US-01 — Initialize and Track Ledger in define-feature Agent ([ca84538](https://github.com/dtlab-tech/ai-toolkit/commit/ca84538d6980828313d331e4a07e10bde5cb34c7))
+* **FTR-013:** implement US-02 — Track Phase 1 Agent Invocations ([a4e3b10](https://github.com/dtlab-tech/ai-toolkit/commit/a4e3b1001bb0b6201c873c4608c23c94c37ca5e0))
+* **FTR-013:** implement US-02 — Track Phase 1 Agent Invocations ([85d86e4](https://github.com/dtlab-tech/ai-toolkit/commit/85d86e406d9ace96b22214de5aef14a6b0cde0b2))
+* **FTR-013:** implement US-03 — Track Phase 2 Agent Invocations ([819f3c3](https://github.com/dtlab-tech/ai-toolkit/commit/819f3c33a954ce89bb221461ee21092b9429c085))
+* **FTR-013:** implement US-03 — Track Phase 2 Agent Invocations ([7d6f9bb](https://github.com/dtlab-tech/ai-toolkit/commit/7d6f9bba8a794e83a12b31a306e27a5d8505c3f7))
+* **FTR-013:** Ledger Pipeline Activity Tracker ([f1bf49a](https://github.com/dtlab-tech/ai-toolkit/commit/f1bf49a4c7496fba8f0c04c5770fe2ad08a6b4ac))
+* **pm:** add EUR cost columns to Token-Estimate ([b0faf0d](https://github.com/dtlab-tech/ai-toolkit/commit/b0faf0dc15c40358bf64b55a0a34987be8db19a2))
+
+
+### Bug Fixes
+
+* **FTR-011:** remediate review issues ([c34d824](https://github.com/dtlab-tech/ai-toolkit/commit/c34d8246fff5548401cb50cc300043679ede4bba))
+* **FTR-012:** remediate review issues ([f9ea280](https://github.com/dtlab-tech/ai-toolkit/commit/f9ea280c394a6436fa6a0840f0110b1b620b6025))
+* **pm:** commit actuals after write-actuals; restore zero-delta ledger entries on resume ([83bbaec](https://github.com/dtlab-tech/ai-toolkit/commit/83bbaecdbbbbf9aa436af8d56a6e823500868b1b))
+* **pm:** correct write-actuals token estimate output ([d45653a](https://github.com/dtlab-tech/ai-toolkit/commit/d45653a2c9f999ec8478836e01128428295fa95a))
+
+## [0.7.0](https://github.com/dtlab-tech/ai-toolkit/compare/v0.6.0...v0.7.0) (2026-07-29)
+
+
+### Features
+
+* **pipeline:** centralized test run + persistent token ledger + validation report fix + smarter define-feature ([c9fad6e](https://github.com/dtlab-tech/ai-toolkit/commit/c9fad6e4e5dfe25823df1d6534b4e597baa97001))
+* **pm-phase3:** add centralized test run phase to streamline testing process ([972fac5](https://github.com/dtlab-tech/ai-toolkit/commit/972fac55d0754743859a7d75379a41acd49a890d))
+* **pm-phase3:** persist token ledger to disk after every phase ([b6ad681](https://github.com/dtlab-tech/ai-toolkit/commit/b6ad6814770fae31cda60f25298dab9b2739eeaa))
+
 ## [0.6.0](https://github.com/dtlab-tech/ai-toolkit/compare/v0.5.0...v0.6.0) (2026-07-29)