@dtlabs/ai-toolkit 0.9.0 → 0.10.0

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

@@ -13,13 +13,15 @@ export const meta = {
 
 async function appendLedgerEntry(featureDir, prefix, entry) {
   const ledgerPath = `${featureDir}/${prefix}-token-ledger.json`
-  // started_at is generated via Bash inside the agent to get a real UTC timestamp with time
-  const entryWithoutTs = JSON.stringify({ ...entry, started_at: '__TS__', completed_at: null })
+  // Defaults come first so the caller can override started_at/completed_at.
+  // Skipped entries pass completed_at: '__TS__' to get a real timestamp; running entries
+  // pass completed_at: null to keep it null. Both are replaced/kept by the agent below.
+  const entryWithoutTs = JSON.stringify({ started_at: '__TS__', completed_at: null, ...entry })
   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` +
+    `3. Push this object onto the array, replacing every "__TS__" string value in the object with NOW: ${entryWithoutTs}\n` +
     `4. Write the full array back (JSON, 2-space indent). Return no output.`,
     { label: 'append-ledger', phase: 'Work Breakdown', model: 'haiku' }
   )
@@ -41,6 +43,48 @@ async function updateLedgerEntry(featureDir, prefix, agentKey, updates) {
   )
 }
 
+// Output schemas for wb-validate and wb-render agent invocations (used by US-05)
+const WB_WRAPPER_SCHEMA = {
+  type: 'object',
+  properties: {
+    exitCode: { type: 'number' },
+    stdout:   { type: 'string' },
+    stderr:   { type: 'string' },
+  },
+  required: ['exitCode', 'stdout', 'stderr'],
+}
+
+const WB_RENDER_SCHEMA = {
+  type: 'object',
+  properties: {
+    exitCode:       { type: 'number' },
+    stdout:         { type: 'string' },
+    stderr:         { type: 'string' },
+    markdownPath:   { type: 'string' },
+    csvPath:        { type: 'string' },
+    markdownExists: { type: 'boolean' },
+    csvExists:      { type: 'boolean' },
+  },
+  required: ['exitCode', 'stdout', 'stderr', 'markdownPath', 'csvPath', 'markdownExists', 'csvExists'],
+}
+
+const WB_SEMANTIC_SCHEMA = {
+  type: 'object',
+  properties: {
+    valid:    { type: 'boolean' },
+    findings: { type: 'array' },
+  },
+  required: ['valid', 'findings'],
+}
+
+function normalizeError(err) {
+  if (!err) return '<unknown error>'
+  if (typeof err === 'string') return err
+  if (err.message) return err.message
+  if (err.stderr) return err.stderr
+  try { return JSON.stringify(err) } catch (_) { return '<unknown error>' }
+}
+
 // ── Parse args ────────────────────────────────────────────────────────────────
 
 // args: "<path-to-feature.md>"
@@ -81,6 +125,225 @@ await updateLedgerEntry(featureDir, prefix, 'generate-work-breakdown:phase2', {
 tokenLedger.push({ agent: 'generate-work-breakdown', model: 'haiku', phase_delta_tokens: wbTokens })
 log(`generate-work-breakdown done — phase delta: ${wbTokens} tokens`)
 
+// ── Step 2: wb-validate.js (deterministic structural validator) ───────────────
+let wbValidatorReport = null
+let validateFailed = false
+let validateExitCode = null
+await appendLedgerEntry(featureDir, prefix, {
+  agent: 'wb-validate:phase2',
+  phase: 'phase2', model: 'haiku', status: 'running',
+  phase_delta_tokens: 0, started_at: '__TS__', completed_at: null,
+})
+const beforeValidate = budget.spent()
+try {
+  const validateWrapper = await agent(
+    `Run this command and return the result as structured output:\n` +
+    `node .claude/scripts/wb-validate.js "${featureDir}/${prefix}-Work-Breakdown.json" "${featureDir}/${prefix}-Requirements.md"\n\n` +
+    `Capture exitCode (integer), stdout (string), stderr (string). Return all three.`,
+    {
+      label:  'wb-validate',
+      phase:  'Work Breakdown',
+      model:  'haiku',
+      schema: WB_WRAPPER_SCHEMA,
+    }
+  )
+  validateExitCode = validateWrapper.exitCode
+  if (validateWrapper.stderr?.trim()) {
+    log(`wb-validate stderr: ${validateWrapper.stderr.trim()}`)
+  }
+  if (validateWrapper.exitCode === 2) {
+    throw Object.assign(
+      new Error(validateWrapper.stderr?.trim() || 'wb-validate runtime error (exit 2)'),
+      { _exitCode: validateWrapper.exitCode }
+    )
+  }
+  if (![0, 1].includes(validateWrapper.exitCode)) {
+    throw Object.assign(
+      new Error(`wb-validate unexpected exit code: ${validateWrapper.exitCode}`),
+      { _exitCode: validateWrapper.exitCode }
+    )
+  }
+  if (!validateWrapper.stdout?.trim()) {
+    throw new Error('wb-validate returned empty stdout')
+  }
+  wbValidatorReport = JSON.parse(validateWrapper.stdout)
+  if (validateWrapper.exitCode === 0 && !wbValidatorReport.valid) {
+    throw new Error('Inconsistent wb-validate result: exit 0 with valid=false')
+  }
+  if (validateWrapper.exitCode === 1 && wbValidatorReport.valid) {
+    throw new Error('Inconsistent wb-validate result: exit 1 with valid=true')
+  }
+  await updateLedgerEntry(featureDir, prefix, 'wb-validate:phase2', {
+    status: 'done', completed_at: '__TS__',
+    phase_delta_tokens: budget.spent() - beforeValidate,
+  })
+} catch (err) {
+  validateFailed = true
+  await updateLedgerEntry(featureDir, prefix, 'wb-validate:phase2', {
+    status: 'failed', completed_at: '__TS__',
+    phase_delta_tokens: budget.spent() - beforeValidate,
+    error_summary: normalizeError(err),
+    exit_code: err._exitCode ?? validateExitCode ?? null,
+  })
+}
+const validateTokens = budget.spent() - beforeValidate
+const wbValidatorPassed = !validateFailed && wbValidatorReport !== null
+  && wbValidatorReport.valid === true && wbValidatorReport.errors.length === 0
+log(`wb-validate: ${wbValidatorPassed ? 'passed' : 'failed/errors'} — ${validateTokens} tokens`)
+
+// ── Step 3: Semantic validator (only if wb-validate passed) ───────────────────
+let semanticResult = null
+let semanticFailed = false
+let semanticTokens = 0
+if (!wbValidatorPassed) {
+  await appendLedgerEntry(featureDir, prefix, {
+    agent: 'validate-work-breakdown-semantic:phase2',
+    phase: 'phase2', model: 'sonnet', status: 'skipped',
+    phase_delta_tokens: 0, started_at: '__TS__', completed_at: '__TS__',
+  })
+} else {
+  await appendLedgerEntry(featureDir, prefix, {
+    agent: 'validate-work-breakdown-semantic:phase2',
+    phase: 'phase2', model: 'sonnet', status: 'running',
+    phase_delta_tokens: 0, started_at: '__TS__', completed_at: null,
+  })
+  const beforeSemantic = budget.spent()
+  try {
+    semanticResult = await agent(
+      `${featureDir}/${prefix}-Work-Breakdown.json\n${featureDir}/${prefix}-Requirements.md`,
+      {
+        label:     'validate-work-breakdown-semantic',
+        phase:     'Work Breakdown',
+        agentType: 'validate-work-breakdown-semantic',
+        schema:    WB_SEMANTIC_SCHEMA,
+      }
+    )
+    semanticTokens = budget.spent() - beforeSemantic
+    await updateLedgerEntry(featureDir, prefix, 'validate-work-breakdown-semantic:phase2', {
+      status: 'done', completed_at: '__TS__', phase_delta_tokens: semanticTokens,
+    })
+  } catch (err) {
+    semanticFailed = true
+    semanticTokens = budget.spent() - beforeSemantic
+    await updateLedgerEntry(featureDir, prefix, 'validate-work-breakdown-semantic:phase2', {
+      status: 'failed', completed_at: '__TS__', phase_delta_tokens: semanticTokens,
+      error_summary: normalizeError(err), exit_code: null,
+    })
+  }
+}
+log(`semantic validator: ${semanticFailed ? 'failed' : semanticResult ? 'done' : 'skipped'}`)
+
+// ── Step 4: wb-render.js (only if wb-validate passed and semantic did not fail) ─
+const canRender = wbValidatorPassed && !semanticFailed
+let renderFailed = false
+let renderResult = null
+if (!canRender) {
+  await appendLedgerEntry(featureDir, prefix, {
+    agent: 'wb-render:phase2',
+    phase: 'phase2', model: 'haiku', status: 'skipped',
+    phase_delta_tokens: 0, started_at: '__TS__', completed_at: '__TS__',
+  })
+} else {
+  await appendLedgerEntry(featureDir, prefix, {
+    agent: 'wb-render:phase2',
+    phase: 'phase2', model: 'haiku', status: 'running',
+    phase_delta_tokens: 0, started_at: '__TS__', completed_at: null,
+  })
+  const beforeRender = budget.spent()
+  try {
+    renderResult = await agent(
+      `Run this command and return the result as structured output:\n` +
+      `node .claude/scripts/wb-render.js "${featureDir}/${prefix}-Work-Breakdown.json" "${prefix}"\n\n` +
+      `Capture exitCode (integer), stdout (string), stderr (string).\n` +
+      `Resolve the expected output paths:\n` +
+      `  markdownPath = "${featureDir}/${prefix}-Work-Breakdown.md"\n` +
+      `  csvPath      = "${featureDir}/${prefix}-Work-Breakdown.csv"\n` +
+      `Check whether each file exists on disk and return:\n` +
+      `  markdownExists (boolean), csvExists (boolean).\n` +
+      `Return all seven fields.`,
+      {
+        label:  'wb-render',
+        phase:  'Work Breakdown',
+        model:  'haiku',
+        schema: WB_RENDER_SCHEMA,
+      }
+    )
+    if (renderResult.stderr?.trim()) {
+      log(`wb-render stderr: ${renderResult.stderr.trim()}`)
+    }
+    if (renderResult.exitCode !== 0) {
+      throw Object.assign(
+        new Error(`wb-render exited ${renderResult.exitCode}: ${renderResult.stderr?.trim() || renderResult.stdout?.trim()}`),
+        { _exitCode: renderResult.exitCode }
+      )
+    }
+    if (!renderResult.markdownPath?.trim()) throw new Error('wb-render did not return markdownPath')
+    if (!renderResult.csvPath?.trim()) throw new Error('wb-render did not return csvPath')
+    if (!renderResult.markdownExists) {
+      throw Object.assign(
+        new Error(`wb-render output file not found: ${renderResult.markdownPath}`),
+        { _exitCode: renderResult.exitCode }
+      )
+    }
+    if (!renderResult.csvExists) {
+      throw Object.assign(
+        new Error(`wb-render output file not found: ${renderResult.csvPath}`),
+        { _exitCode: renderResult.exitCode }
+      )
+    }
+    await updateLedgerEntry(featureDir, prefix, 'wb-render:phase2', {
+      status: 'done', completed_at: '__TS__',
+      phase_delta_tokens: budget.spent() - beforeRender,
+    })
+  } catch (err) {
+    renderFailed = true
+    await updateLedgerEntry(featureDir, prefix, 'wb-render:phase2', {
+      status: 'failed', completed_at: '__TS__',
+      phase_delta_tokens: budget.spent() - beforeRender,
+      error_summary: normalizeError(err),
+      exit_code: err._exitCode ?? renderResult?.exitCode ?? null,
+    })
+  }
+  tokenLedger.push({ agent: 'wb-render', model: 'haiku', phase_delta_tokens: budget.spent() - beforeRender })
+}
+
+tokenLedger.push({ agent: 'wb-validate', model: 'haiku', phase_delta_tokens: validateTokens })
+tokenLedger.push({ agent: 'validate-work-breakdown-semantic', model: 'sonnet', phase_delta_tokens: semanticTokens })
+
+// ── Step 5: Assemble gate2_payload ────────────────────────────────────────────
+const gate2_payload = {
+  js_validator_report:       wbValidatorReport,
+  js_validator_failed:       validateFailed,
+  semantic_validator_result: semanticResult,
+  semantic_validator_failed: semanticFailed,
+  renderer_result:           renderResult,
+  renderer_failed:           renderFailed,
+  duration_bands:      wbValidatorReport ? wbValidatorReport.durationBands : null,
+  domain_distribution: wbValidatorReport ? wbValidatorReport.domainDistribution : null,
+  warning_band_tasks:  wbValidatorReport
+    ? wbValidatorReport.warnings.filter(w => w.category === 'duration_warning')
+        .map(w => ({ taskId: w.taskId, agentMinutes: w.details ? w.details.agentMinutes : null }))
+    : [],
+  split_required_tasks: wbValidatorReport
+    ? wbValidatorReport.errors.filter(e => e.category === 'split_required')
+        .map(e => ({ taskId: e.taskId, agentMinutes: e.details ? e.details.agentMinutes : null }))
+    : [],
+  must_ac_uncovered: wbValidatorReport
+    ? wbValidatorReport.errors.filter(e => e.category === 'must_ac_uncovered')
+        .map(e => ({ acId: e.details ? e.details.acId : null }))
+    : [],
+  phase_unschedulable: wbValidatorReport
+    ? (wbValidatorReport.dependencies ? wbValidatorReport.dependencies.phaseUnschedulable || [] : [])
+    : [],
+  gate2_blocked:
+    validateFailed ||
+    !wbValidatorPassed ||
+    semanticFailed ||
+    renderFailed ||
+    Boolean(semanticResult && semanticResult.findings && semanticResult.findings.some(f => f.blocking)),
+}
+log(`gate2_payload assembled — gate2_blocked: ${gate2_payload.gate2_blocked}`)
+
 // ── Parse WB + write Effort-Estimate + Token-Estimate ────────────────────────
 phase('Effort Estimate')
 
@@ -135,30 +398,27 @@ function formatEur(val) {
 const metrics = await agent(
   `You have four tasks:
 
-TASK 1 — Read the Work Breakdown file.
+TASK 1 — Read the Work Breakdown JSON file.
 The feature.md is at: ${featurePath}
-The directory containing feature.md also contains the Work Breakdown file named {PREFIX}-Work-Breakdown.md,
-where PREFIX matches the pattern [A-Z]+-[0-9]+ from the directory name (e.g. FTR-009).
-Use Glob or Read to find and read that file.
-
-Extract from the Summary table:
-- prefix (e.g. "FTR-009")
-- feature_dir (directory containing feature.md)
-- feature_title (full feature title from the Work Breakdown header)
-- user_stories (integer)
-- total_tasks (integer)
-- domain_breakdown (e.g. "DB:0, BE:11, FE:0, INFRA:4, TEST:0")
-- implementation_phases (integer)
-- human_estimate (e.g. "~34h")
-- agent_estimate (e.g. "~2h 6min")
-- work_breakdown_path (full path to the Work Breakdown file)
-
-Also read Section 4 of the Work Breakdown to extract per-User-Story details:
-- US ID (e.g. US-01)
-- US title
-- task count
-- domains involved
-- estimated hours (from the Work Breakdown if present, otherwise estimate based on task count: ~2h per BE task, ~1h per TEST task, ~30min per INFRA task)
+The JSON work breakdown is at: ${featureDir}/${prefix}-Work-Breakdown.json
+Read the JSON file and extract:
+- prefix (e.g. "FTR-009") — use "${prefix}"
+- feature_dir (directory containing feature.md) — use "${featureDir}"
+- feature_title — from wb.title or wb.feature field
+- total_tasks (integer) — count all tasks across all phases
+- user_stories (integer) — count phases whose id starts with "US-"
+- domain_breakdown (string) — e.g. "BE: N, FE: N, DB: N, INFRA: N, TEST: N"
+- implementation_phases (integer) — total number of phases
+- human_estimate — compute as: (BE_tasks * 120 + TEST_tasks * 60 + INFRA_tasks * 30 + FE_tasks * 90 + DB_tasks * 90) minutes, format as "~Xh Ymin"
+- agent_estimate — human_estimate / 4 (parallel dispatch), format as "~Xmin" or "~Xh Ymin"
+- work_breakdown_path — ${featureDir}/${prefix}-Work-Breakdown.json
+
+Also extract per-User-Story details for the Effort-Estimate:
+- US ID (phase.id where it starts with "US-")
+- US title (phase.title)
+- task count (phase.tasks.length)
+- domains involved (unique task.domain values in the phase)
+- estimated hours (per the formula above)
 
 TASK 2 — Write the Effort-Estimate.md file.
 Write {feature_dir}/{PREFIX}-Effort-Estimate.md with this format:
@@ -245,7 +505,7 @@ For the "Est. cost €" column in Phase 3: use the formula tokens * (0.8 * 3.00
 TASK 4 — Set return values.
 Set effort_estimate_path to the full path of the written Effort-Estimate.md.
 Set token_estimate_path to the full path of the written Token-Estimate.md.
-Set tasks_csv_path to the full path of the {PREFIX}-Work-Breakdown.csv file (written by generate-work-breakdown in the same directory as feature.md).
+Set tasks_csv_path to "${featureDir}/${prefix}-Work-Breakdown.csv" (written by wb-render in the same directory as feature.md).
 
 Return the extracted metrics as structured output.`,
   {
@@ -287,7 +547,7 @@ ${phase2Events}`,
 )
 
 return {
-  prefix:                metrics.prefix,
+  prefix:                metrics.prefix || prefix,
   feature_path:          featurePath,
   user_stories:          metrics.user_stories,
   total_tasks:           metrics.total_tasks,
@@ -301,4 +561,5 @@ return {
   tasks_csv_path:        metrics.tasks_csv_path        || '',
   token_ledger:          tokenLedger,
   errors:                [],
+  gate2_payload,
 }

package/CHANGELOG.md

@@ -1,4 +1,71 @@
 ## 0.1.4 (2026-07-21)
+## [0.10.0](https://github.com/dtlab-tech/ai-toolkit/compare/v0.9.0...v0.10.0) (2026-08-12)
+
+
+### Features
+
+* **FTR-014:** Atomic Work Breakdown validation pipeline ([59a3be5](https://github.com/dtlab-tech/ai-toolkit/commit/59a3be511238229ca49f280262306b26e5ceb9a0))
+* **FTR-014:** INFRA-T01 Create .claude/scripts/ directory structure ([27773ac](https://github.com/dtlab-tech/ai-toolkit/commit/27773ac03d916ddb64acba03e2f9a21985a59886))
+* **FTR-014:** INFRA-T02 Define WB JSON schema v2 constants ([52c45d0](https://github.com/dtlab-tech/ai-toolkit/commit/52c45d06576e2a7717f98d056953ae6ad821cc75))
+* **FTR-014:** INFRA-T03 Create AC table parser test fixture ([4e6a7a3](https://github.com/dtlab-tech/ai-toolkit/commit/4e6a7a3490f4de53354ac7ae384a00f0e4f98e34))
+* **FTR-014:** INFRA-T04 Define WB_WRAPPER_SCHEMA and WB_RENDER_SCHEMA in pm-phase2.js ([b92e81c](https://github.com/dtlab-tech/ai-toolkit/commit/b92e81c348f3ec4fc2b3b8fe14fd6ecdbd60c3fa))
+* **FTR-014:** INFRA-T05 Create valid and invalid WB JSON test fixtures ([ea5233c](https://github.com/dtlab-tech/ai-toolkit/commit/ea5233c4b1fccd782682533596ddd4febadd3c29))
+* **FTR-014:** INFRA-T06 Extract buildWaves algorithm as shared test utility ([0b2fd25](https://github.com/dtlab-tech/ai-toolkit/commit/0b2fd25bf0d11679b0fef9140bf688b811316f8c))
+* **FTR-014:** INFRA-T07 Define duration policy constants in wb-validate.js ([cd6cfee](https://github.com/dtlab-tech/ai-toolkit/commit/cd6cfee7bffb4dfd1d9ebbf1cc4732cc9def6acf))
+* **FTR-014:** INFRA-T08 Define wb-validate error catalog constants ([06a9cd8](https://github.com/dtlab-tech/ai-toolkit/commit/06a9cd8d4f4e3583b84ac62ae94138184a8d96b8))
+* **FTR-014:** US-01-T01 Update generate-work-breakdown.md to produce schema v2 JSON ([44a9674](https://github.com/dtlab-tech/ai-toolkit/commit/44a9674f897bcb70cbddd11cd9f72f220765e512))
+* **FTR-014:** US-01-T02 Generate Work Breakdown JSON for a test feature ([8b1f3ed](https://github.com/dtlab-tech/ai-toolkit/commit/8b1f3ed65cb75350c2f2c181f5a1e8a8a7642a10))
+* **FTR-014:** US-01-T03 Verify schema v2 compliance of generated JSON ([afdc774](https://github.com/dtlab-tech/ai-toolkit/commit/afdc774b0fc56466eaddbb462bb1230ad31b7792))
+* **FTR-014:** US-02-T01 Implement wb-validate.js entry point and schema version check ([8ff1c30](https://github.com/dtlab-tech/ai-toolkit/commit/8ff1c308934830551c0bae6a1122e68af10dbcd9))
+* **FTR-014:** US-02-T02 Implement unique ID and required field validation ([c426adc](https://github.com/dtlab-tech/ai-toolkit/commit/c426adc3796cc0705a40bb8ac34b1b79ca9f85d0))
+* **FTR-014:** US-02-T03 Implement task ID format, domain, agentType validation ([a2166f7](https://github.com/dtlab-tech/ai-toolkit/commit/a2166f76a1b9e4f1cd7de0925e9ff20fe6d2cb36))
+* **FTR-014:** US-02-T04 Implement task dependency resolution — refs, self-dep, phase consistency ([8fe5906](https://github.com/dtlab-tech/ai-toolkit/commit/8fe59060643a2704ce8aa1bd8a363c8a4a1794ef))
+* **FTR-014:** US-02-T05 Implement task cycle detection (DFS gray/black coloring) ([94e18a3](https://github.com/dtlab-tech/ai-toolkit/commit/94e18a342ae025ff7574ee1fd9b038a6de4dea60))
+* **FTR-014:** US-02-T06 Implement phase-level dependency projection and cycle detection ([a6e7469](https://github.com/dtlab-tech/ai-toolkit/commit/a6e7469541957a2dab3a3d525a87f060f64b2ecd))
+* **FTR-014:** US-02-T07 Implement phase schedulability check (buildWaves) ([6a710a1](https://github.com/dtlab-tech/ai-toolkit/commit/6a710a13c4a4e3132f79f90f9f0d286120e64fb0))
+* **FTR-014:** US-02-T08 Implement duration policy checks (four-band classification) ([44a61fb](https://github.com/dtlab-tech/ai-toolkit/commit/44a61fb62370e06eb7ac1f6e20d0b3e2ec628195))
+* **FTR-014:** US-02-T09 Implement verification commands, commit subject, grouping rationale checks ([cbd64f0](https://github.com/dtlab-tech/ai-toolkit/commit/cbd64f00331e03ac9582b656c3e75b0921246630))
+* **FTR-014:** US-02-T10 Implement AC table parser (Section 3.2 contract) ([317abe4](https://github.com/dtlab-tech/ai-toolkit/commit/317abe4f4a5848370a68d6ad3bae7e8a92755c53))
+* **FTR-014:** US-02-T11 Implement AC existence and scope validation (checks 19-20) ([132e97a](https://github.com/dtlab-tech/ai-toolkit/commit/132e97a804175a2d5b2a97cfbc8816031ea81c87))
+* **FTR-014:** US-02-T12 Implement AC priority derivation and Must coverage check (check 21) ([6483986](https://github.com/dtlab-tech/ai-toolkit/commit/6483986959a603ba1dc75c321db9b08d8808a2be))
+* **FTR-014:** US-02-T13 Implement text field character validation and empty phase detection (checks 22-23) ([d93464e](https://github.com/dtlab-tech/ai-toolkit/commit/d93464e13444e0969a5cb9e58ad0a1c0fc3b865c))
+* **FTR-014:** US-02-T14 Implement domain distribution in validator report output ([2d462f0](https://github.com/dtlab-tech/ai-toolkit/commit/2d462f07a00be04275d15608d2916e15b56df44b))
+* **FTR-014:** US-02-T15 Add Jest suite for wb-validate checks 1-7 (schema, IDs, fields, format, domain, agentType) ([0affff6](https://github.com/dtlab-tech/ai-toolkit/commit/0affff6d986ab3da1b321e1baae91cc49fa402e1))
+* **FTR-014:** US-02-T16 Add Jest suite for wb-validate checks 8-10 (task deps, self-dep, phase consistency) ([17427a2](https://github.com/dtlab-tech/ai-toolkit/commit/17427a2ab900238bf757a11040bb1380dc49fa4e))
+* **FTR-014:** US-02-T17 Add Jest suite for wb-validate check 11 (task cycle detection) ([43e06aa](https://github.com/dtlab-tech/ai-toolkit/commit/43e06aa95fc7203be5d5594443d5dd8a891ba71a))
+* **FTR-014:** US-02-T18 Add Jest suite for wb-validate checks 12-14 (phase graph, cycles, schedulability) ([a4f710e](https://github.com/dtlab-tech/ai-toolkit/commit/a4f710e6ab996251d98af5006f519a497d7ca850))
+* **FTR-014:** US-02-T19 Add Jest suite for wb-validate checks 15-18 (duration policy, commands, commit, rationale) ([3bdfc81](https://github.com/dtlab-tech/ai-toolkit/commit/3bdfc810f4dea82e29493e06fb98e83991d21c9c))
+* **FTR-014:** US-02-T20 Add Jest suite for wb-validate checks 19-21 (AC parsing, scope, priority, Must coverage) ([e237c8e](https://github.com/dtlab-tech/ai-toolkit/commit/e237c8e03f83a499e4f265c2f67ed51b629967f2))
+* **FTR-014:** US-02-T21 Add Jest suite for wb-validate checks 22-23 and report output contract ([9cbb57a](https://github.com/dtlab-tech/ai-toolkit/commit/9cbb57a5f8d781fb20e84235d8c492032c102893))
+* **FTR-014:** US-03-T01 Create validate-work-breakdown-semantic agent definition ([6b34656](https://github.com/dtlab-tech/ai-toolkit/commit/6b3465634632f03f9c79ab27f31a8e842971d66d))
+* **FTR-014:** US-03-T02 US-03-T03 Semantic analysis logic and structured output (covered by T01 agent definition) ([762b648](https://github.com/dtlab-tech/ai-toolkit/commit/762b64853d52b42f9535f4531cb4010d66ae4da2))
+* **FTR-014:** US-03-T04 Manual semantic validation on test features (7/7 schema checks PASS) ([db6ee3c](https://github.com/dtlab-tech/ai-toolkit/commit/db6ee3cefc698216876f479b5fdbe64120e7e2bf))
+* **FTR-014:** US-04-T01 Implement wb-render.js entry point (arg parsing, JSON read, file path setup) ([3d82ca3](https://github.com/dtlab-tech/ai-toolkit/commit/3d82ca3d7427df5e6208c58d1d1625224bcd079f))
+* **FTR-014:** US-04-T02 Implement phase-level depends_on aggregation in wb-render.js ([726a756](https://github.com/dtlab-tech/ai-toolkit/commit/726a756cfee589ea9a2879c7f5d2732ccea682c8))
+* **FTR-014:** US-04-T03 Implement defensive character stripping and commit message construction ([d9262dc](https://github.com/dtlab-tech/ai-toolkit/commit/d9262dc25866100afe74fe468a963c5034745c9a))
+* **FTR-014:** US-04-T04 Implement Markdown output generation in wb-render.js ([2a7a384](https://github.com/dtlab-tech/ai-toolkit/commit/2a7a3842f642cb514e6efd48d94d8f818a3a1414))
+* **FTR-014:** US-04-T05 Implement CSV output generation in wb-render.js ([1c2a386](https://github.com/dtlab-tech/ai-toolkit/commit/1c2a386078ae54015048f32b76a3789efa82f03a))
+* **FTR-014:** US-04-T06 Tests for Markdown structure, CSV structure, dependency aggregation ([03de433](https://github.com/dtlab-tech/ai-toolkit/commit/03de433b1643751d68abc5dc121715c75872775d))
+* **FTR-014:** US-04-T07 Tests for character stripping, commit construction, output file paths ([ace21ba](https://github.com/dtlab-tech/ai-toolkit/commit/ace21ba2f1eff5777254a9174a3f4b2ff0383b97))
+* **FTR-014:** US-04-T08 CSV regression test against pm-phase3 parser ([3a83ed5](https://github.com/dtlab-tech/ai-toolkit/commit/3a83ed5a1dd3f9bb8add57e8abc97b8f80303a62))
+* **FTR-014:** US-05-T01..T06 Update pm-phase2.js with validation pipeline and gate2_payload ([711b71e](https://github.com/dtlab-tech/ai-toolkit/commit/711b71e8b3d3f78a7cac43841fc9b42625d4749b))
+* **FTR-014:** US-05-T07 Update implement-feature SKILL.md Gate 2 presentation with validator results ([e617b3d](https://github.com/dtlab-tech/ai-toolkit/commit/e617b3d28036969adecff78c26df382e871e9ed2))
+* **FTR-014:** US-05-T08 Tests for orchestration flow wb-validate to semantic to render ([c1341e2](https://github.com/dtlab-tech/ai-toolkit/commit/c1341e23566d6efaa33c58db368d52fdbbef9fe1))
+* **FTR-014:** US-05-T09 Tests for Gate 2 blocking logic and gate2_payload assembly ([8421695](https://github.com/dtlab-tech/ai-toolkit/commit/8421695ff0aeee3f9fd0d01d21cfc863a9344c91))
+* **FTR-014:** US-06-T01..T04 Ledger tracking for wb-validate, semantic, wb-render in pm-phase2 ([2f9a9f7](https://github.com/dtlab-tech/ai-toolkit/commit/2f9a9f7ff935314bb591a4d1bb8ea8eaf9ad19bc))
+* **FTR-014:** US-07-T01..T02 Add .claude/scripts/ to installer distribution for wb-validate and wb-render ([bcba12a](https://github.com/dtlab-tech/ai-toolkit/commit/bcba12ad340d071b794dd6608318e34dea7e846b))
+* **FTR-014:** US-07-T03..T05 Tests for installer script distribution verification ([2bb57bd](https://github.com/dtlab-tech/ai-toolkit/commit/2bb57bd4a918052ed05a421d310ae2124252a6f8))
+
+
+### Bug Fixes
+
+* **FTR-014:** align warning/split task details field to agentMinutes ([ba7dbf8](https://github.com/dtlab-tech/ai-toolkit/commit/ba7dbf8f8dd5e34f55bc825bdefabdaaf2160eba))
+* **FTR-014:** enforce groupingRationale as a required task field in check 4 ([e5cb733](https://github.com/dtlab-tech/ai-toolkit/commit/e5cb7336e91f44c653d979cfeba8f21de3da3d19))
+* **FTR-014:** guard wb.phases in checks 22 and 23 against missing/non-array ([32ec505](https://github.com/dtlab-tech/ai-toolkit/commit/32ec50560c5e1fe855ac15bf9d40ec7b0ba3d8ae))
+* **FTR-014:** preserve completed_at for skipped ledger entries (I6) ([389f280](https://github.com/dtlab-tech/ai-toolkit/commit/389f280d4ebdfc6a3d694e9c9e43e57042043493))
+* **FTR-014:** relax symmetric-wrapping assertion in pm-phase2-source test ([8bc663e](https://github.com/dtlab-tech/ai-toolkit/commit/8bc663ec098d645cf3e6dcdd7793a08e44104784))
+* **FTR-014:** use exit(2) for parseAcTable fatal errors (I5) ([1244066](https://github.com/dtlab-tech/ai-toolkit/commit/12440663cf57ddfea523535829ebbb9a66a300fd))
+
 ## [0.9.0](https://github.com/dtlab-tech/ai-toolkit/compare/v0.8.0...v0.9.0) (2026-08-05)
 
 

package/bin/cli.js

@@ -679,6 +679,7 @@ async function installGlobal(force) {
       { src: path.join(packageRoot, '.claude', 'skills'),    dest: path.join(target, 'skills') },
       { src: path.join(packageRoot, '.claude', 'commands'),  dest: path.join(target, 'commands') },
       { src: path.join(packageRoot, '.claude', 'workflows'), dest: path.join(target, 'workflows') },
+      { src: path.join(packageRoot, '.claude', 'scripts'),   dest: path.join(target, 'scripts') },
       { src: path.join(packageRoot, 'docs'),                 dest: path.join(target, 'docs') },
       { src: path.join(packageRoot, 'CLAUDE.global.md'),    dest: path.join(target, 'CLAUDE.md') },
     ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dtlabs/ai-toolkit",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "AI Toolkit — reusable agents and procedures for developers to build AI-powered applications.",
   "files": [
     "docs/",