@dtlabs/ai-toolkit 0.7.0 → 0.9.0

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

@@ -11,6 +11,40 @@ export const meta = {
   ],
 }
 
+// ── Ledger helper functions ───────────────────────────────────────────────────
+// Route all ledger I/O through agent() — fs and require() are not available in
+// the Workflow runtime. Mirrors the pattern used by pm-phase2.js.
+
+async function appendLedgerEntry(featureDir, prefix, entry) {
+  const ledgerPath = `${featureDir}/${prefix}-token-ledger.json`
+  const entryWithoutTs = JSON.stringify({ ...entry, started_at: '__TS__', completed_at: null })
+  await agent(
+    `Append a JSON object to the ledger array at: ${ledgerPath}\n\n` +
+    `1. Run: date -u +"%Y-%m-%dT%H:%M:%SZ" and capture the output as NOW.\n` +
+    `2. Read the file. If it does not exist or cannot be parsed as a JSON array, start with [].\n` +
+    `3. Push this object onto the array, replacing "__TS__" in started_at with NOW: ${entryWithoutTs}\n` +
+    `4. Write the full array back (JSON, 2-space indent). Return no output.`,
+    { label: 'append-ledger', phase: 'Implementation', model: 'haiku' }
+  )
+}
+
+async function updateLedgerEntry(featureDir, prefix, agentKey, updates) {
+  const ledgerPath = `${featureDir}/${prefix}-token-ledger.json`
+  const updatesWithoutTs = JSON.stringify({ ...updates, completed_at: '__TS__' })
+  await agent(
+    `Update an entry in the ledger array at: ${ledgerPath}\n\n` +
+    `1. Run: date -u +"%Y-%m-%dT%H:%M:%SZ" and capture the output as NOW.\n` +
+    `2. Read the file. If it does not exist or cannot be parsed as a JSON array, do nothing.\n` +
+    `3. Search from the end for the last entry where agent === "${agentKey}".\n` +
+    `4. If found, merge these fields into that entry, replacing "__TS__" in completed_at with NOW: ${updatesWithoutTs}\n` +
+    `5. Write the full array back (JSON, 2-space indent). Return no output.\n` +
+    `6. If not found, do nothing.`,
+    { label: 'update-ledger', phase: 'Implementation', model: 'haiku' }
+  )
+}
+
+// ── Parse args ────────────────────────────────────────────────────────────────
+
 // args: "<path-to-feature.md> --branch feature/FTR-NNN-slug"
 const argStr      = typeof args === 'string' ? args : ''
 const featurePath = argStr.trim().split(/\s+/)[0]
@@ -31,10 +65,13 @@ const csvPath     = `${featureDir}/${prefix}-Work-Breakdown.csv`
 
 log(`Reading CSV: ${csvPath}`)
 
+await appendLedgerEntry(featureDir, prefix, { agent: 'read-wb-csv:phase3', phase: 'phase3', model: 'haiku', status: 'running', phase_delta_tokens: 0, started_at: '__TS__', completed_at: null })
+const beforeCsv = budget.spent()
 const csvContent = await agent(
   `Read the file at path: ${csvPath}\nReturn ONLY the raw file contents, nothing else. No explanation, no formatting, no JSON wrapping — just the raw text of the file.`,
   { label: 'read-wb-csv', phase: 'Parse', model: 'haiku' }
 )
+await updateLedgerEntry(featureDir, prefix, 'read-wb-csv:phase3', { status: 'done', completed_at: '__TS__', phase_delta_tokens: budget.spent() - beforeCsv })
 
 // Parse CSV into structured phases — pure JS, no AI
 const rows = csvContent
@@ -148,6 +185,8 @@ const executePhase = async (implPhase) => {
 
     // Step 1 — impl groups in parallel (INFRA / BE / FE)
     if (implPhase.impl_groups.length > 0) {
+      const implKey = `${implPhase.impl_groups.map(g => g.agent_type).join('+')}:${implPhase.phase_id}${reworkCycle > 0 ? ':rework' + reworkCycle : ''}`
+      await appendLedgerEntry(featureDir, prefix, { agent: implKey, phase: 'phase3', model: 'sonnet', status: 'running', phase_delta_tokens: 0, started_at: '__TS__', completed_at: null })
       const beforeImpl = budget.spent()
       await parallel(implPhase.impl_groups.map(group => () =>
         agent(
@@ -160,16 +199,15 @@ const executePhase = async (implPhase) => {
         )
       ))
       const implTokens = budget.spent() - beforeImpl
-      tokenLedger.push({
-        agent: `${implPhase.impl_groups.map(g => g.agent_type).join('+')}:${implPhase.phase_id}${reworkCycle > 0 ? ':rework' + reworkCycle : ''}`,
-        model: 'sonnet',
-        phase_delta_tokens: implTokens,
-      })
+      await updateLedgerEntry(featureDir, prefix, implKey, { status: 'done', completed_at: '__TS__', phase_delta_tokens: implTokens })
+      tokenLedger.push({ agent: implKey, model: 'sonnet', phase_delta_tokens: implTokens })
       log(`Phase ${implPhase.phase_id} impl groups done — ${implTokens} tokens`)
     }
 
     // Step 2 — test groups in parallel (TEST) — after impl groups
     if (implPhase.test_groups.length > 0) {
+      const testKey = `developer-testing:${implPhase.phase_id}${reworkCycle > 0 ? ':rework' + reworkCycle : ''}`
+      await appendLedgerEntry(featureDir, prefix, { agent: testKey, phase: 'phase3', model: 'sonnet', status: 'running', phase_delta_tokens: 0, started_at: '__TS__', completed_at: null })
       const beforeTest = budget.spent()
       await parallel(implPhase.test_groups.map(group => () =>
         agent(
@@ -182,15 +220,14 @@ const executePhase = async (implPhase) => {
         )
       ))
       const testTokens = budget.spent() - beforeTest
-      tokenLedger.push({
-        agent: `developer-testing:${implPhase.phase_id}${reworkCycle > 0 ? ':rework' + reworkCycle : ''}`,
-        model: 'sonnet',
-        phase_delta_tokens: testTokens,
-      })
+      await updateLedgerEntry(featureDir, prefix, testKey, { status: 'done', completed_at: '__TS__', phase_delta_tokens: testTokens })
+      tokenLedger.push({ agent: testKey, model: 'sonnet', phase_delta_tokens: testTokens })
       log(`Phase ${implPhase.phase_id} test groups done — ${testTokens} tokens`)
     }
 
     // Step 3 — review-solution
+    const reviewKey = `review-solution:${implPhase.phase_id}`
+    await appendLedgerEntry(featureDir, prefix, { agent: reviewKey, phase: 'phase3', model: 'sonnet', status: 'running', phase_delta_tokens: 0, started_at: '__TS__', completed_at: null })
     const beforeReview = budget.spent()
     const review = await agent(
       `${featurePath} --scope ${implPhase.phase_id}`,
@@ -202,8 +239,9 @@ const executePhase = async (implPhase) => {
       }
     )
     const reviewTokens = budget.spent() - beforeReview
+    await updateLedgerEntry(featureDir, prefix, reviewKey, { status: 'done', completed_at: '__TS__', phase_delta_tokens: reviewTokens })
     tokenLedger.push({
-      agent: `review-solution:${implPhase.phase_id}`,
+      agent: reviewKey,
       model: 'sonnet',
       phase_delta_tokens: reviewTokens,
     })
@@ -238,16 +276,6 @@ 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
@@ -285,6 +313,7 @@ log(`Implementation complete — ${phasesDone} phases, ${usPassed.length} US pas
 // contention down to a single centralized run with one consolidated failure report.
 phase('Test')
 
+await appendLedgerEntry(featureDir, prefix, { agent: 'final-test-run', phase: 'phase3', model: 'haiku', status: 'running', phase_delta_tokens: 0, started_at: '__TS__', completed_at: null })
 const beforeTest = budget.spent()
 await agent(
   `Run the full test suite in the repository root and report the result.
@@ -297,6 +326,7 @@ Do NOT fix failing tests — only report them.`,
   { label: 'final-test-run', phase: 'Test', model: 'haiku' }
 )
 const testTokens = budget.spent() - beforeTest
+await updateLedgerEntry(featureDir, prefix, 'final-test-run', { status: 'done', completed_at: '__TS__', phase_delta_tokens: testTokens })
 tokenLedger.push({ agent: 'final-test-run', model: 'haiku', phase_delta_tokens: testTokens })
 log(`Test run complete — ${testTokens} tokens`)
 
@@ -317,6 +347,7 @@ let issuesDeferred = 0
 
 if (issuesOpen > 0 && issuesPath) {
   log(`Remediation: ${issuesOpen} OPEN issues`)
+  await appendLedgerEntry(featureDir, prefix, { agent: 'remediation', phase: 'phase3', model: 'sonnet', status: 'running', phase_delta_tokens: 0, started_at: '__TS__', completed_at: null })
   const beforeRem = budget.spent()
 
   const remResult = await agent(
@@ -339,6 +370,7 @@ Update the Issues Register Status column in place for each resolved/deferred iss
   )
 
   const remTokens = budget.spent() - beforeRem
+  await updateLedgerEntry(featureDir, prefix, 'remediation', { status: 'done', completed_at: '__TS__', phase_delta_tokens: remTokens })
   tokenLedger.push({ agent: 'remediation', model: 'sonnet', phase_delta_tokens: remTokens })
   issuesFixed    = remResult.issues_fixed    || 0
   issuesDeferred = remResult.issues_deferred || 0
@@ -359,6 +391,7 @@ const PR_SCHEMA = {
   required: ['pr_url'],
 }
 
+await appendLedgerEntry(featureDir, prefix, { agent: 'pr-and-registry', phase: 'phase3', model: 'sonnet', status: 'running', phase_delta_tokens: 0, started_at: '__TS__', completed_at: null })
 const beforePR = budget.spent()
 
 const prResult = await agent(
@@ -408,6 +441,7 @@ If the PR creation fails, return { "pr_url": "(PR creation failed)", "registry_u
 )
 
 const prTokens = budget.spent() - beforePR
+await updateLedgerEntry(featureDir, prefix, 'pr-and-registry', { status: 'done', completed_at: '__TS__', phase_delta_tokens: prTokens })
 tokenLedger.push({ agent: 'pr-and-registry', model: 'sonnet', phase_delta_tokens: prTokens })
 log(`PR done: ${prResult.pr_url} — ${prTokens} tokens`)
 
@@ -425,12 +459,19 @@ const persistedLedgerRaw = await agent(
 try {
   const persisted = JSON.parse(typeof persistedLedgerRaw === 'string' ? persistedLedgerRaw.trim() : '[]')
   if (Array.isArray(persisted)) {
-    const seen = new Set(tokenLedger.map(e => e.agent))
+    const inMemoryByAgent = new Map(tokenLedger.map((e, i) => [e.agent, i]))
     for (const entry of persisted) {
-      if (entry && entry.agent && !seen.has(entry.agent)) {
+      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)
-        seen.add(entry.agent)
+        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)`)
       }
     }
   }
@@ -440,6 +481,44 @@ try {
 
 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: {
@@ -449,6 +528,7 @@ const ACTUALS_SCHEMA = {
   required: [],
 }
 
+await appendLedgerEntry(featureDir, prefix, { agent: 'write-actuals', phase: 'phase3', model: 'sonnet', status: 'running', phase_delta_tokens: 0, started_at: '__TS__', completed_at: null })
 const beforeActuals = budget.spent()
 
 await agent(
@@ -462,30 +542,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}** |
+
+   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 3 — Implementation (Actuals)
+2. Immediately after that table, add the per-agent detail as a sub-table (source of truth):
 
-> Phase totals are exact measurements from budget tracking.
-> Per-agent values are exact where each agent ran separately; proportional where merged.
+### Phase 3 — per-agent detail (actuals)
 
-| Agent | Phase | Model | Tokens Est. | Tokens Actual |
-|-------|-------|-------|------------|--------------|
-${tokenLedger.map(e => `| ${e.agent} | — | ${e.model} | — | ${e.phase_delta_tokens} |`).join('\n')}
-| **Phase 3 total** | | | **—** | **${totalPhase3Tokens}** |
+| 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}** |
 
-## Grand Total (updated)
+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. | Tokens Actual |
-|-------|------------|--------------|
-| Phase 1 — Documentation | — | *(see above)* |
-| Phase 2 — Work Breakdown | — | *(see above)* |
-| Phase 3 — Implementation | *(see above)* | ${totalPhase3Tokens} |
+| 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
 
@@ -495,6 +595,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)")
@@ -520,6 +622,7 @@ Return { "token_estimate_path": "<path>", "effort_estimate_path": "<path>" }.`,
 )
 
 const actualsTokens = budget.spent() - beforeActuals
+await updateLedgerEntry(featureDir, prefix, 'write-actuals', { status: 'done', completed_at: '__TS__', phase_delta_tokens: actualsTokens })
 tokenLedger.push({ agent: 'write-actuals', model: 'sonnet', phase_delta_tokens: actualsTokens })
 log(`Actuals written — ${actualsTokens} tokens`)
 
@@ -558,6 +661,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,61 @@
 ## 0.1.4 (2026-07-21)
+## [0.9.0](https://github.com/dtlab-tech/ai-toolkit/compare/v0.8.0...v0.9.0) (2026-08-05)
+
+
+### Features
+
+* **FTR-020:** add initial documentation for Atomic Work Breakdown, Execution Ledger, and Task Checkpoints and Resume ([c5f724a](https://github.com/dtlab-tech/ai-toolkit/commit/c5f724af068e003d36ec196cdec3502fe0c47333))
+
+
+### Bug Fixes
+
+* **pm-phase3:** replace require/fs/execSync with agent()-based ledger helpers ([1166d6f](https://github.com/dtlab-tech/ai-toolkit/commit/1166d6f17e913405ea737e74236742569740cd0a))
+* **pm-phase3:** replace require/fs/execSync with agent()-based ledger helpers ([bf4077c](https://github.com/dtlab-tech/ai-toolkit/commit/bf4077cca28920876185535aa553ec91c6ffc08b))
+* **pm-phase3:** replace require/fs/execSync with agent()-based ledger helpers ([bb4c88d](https://github.com/dtlab-tech/ai-toolkit/commit/bb4c88df20c62db09de327975ab57e045247dc51))
+* **workflows:** remove new Date() from all workflow call sites ([343b604](https://github.com/dtlab-tech/ai-toolkit/commit/343b604dba2d4d0b12e5590c1b5323b2a9e888f2))
+
+## [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)