dw-kit 1.7.0-rc.1 → 1.7.0-rc.2

package/.claude/hooks/pre-commit-gate.sh

@@ -96,27 +96,25 @@ fi
 # v1.6 (ADR-0009 R2-2): Agent OS post-hoc check.
 # When ≥1 active claim exists, verify staged files fall within an active claim's write_scope.
 # Cooperative protocol — warn only (cannot prevent non-compliant agents).
-if [ -f "$DW_BIN" ] && command -v node >/dev/null 2>&1 && [ -n "$STAGED_FILES" ]; then
+#
+# Issue #13 Bug 3 fix: previous version inlined `node -e` importing
+# `$CLAUDE_PROJECT_DIR/src/lib/agent-claim.mjs` — that path is cwd-relative and
+# only exists in dw-kit's own repo, NOT in consumer projects. The block was
+# silently no-op everywhere else. Replaced by `dw agent check-staged --stdin`
+# which uses the installed binary. Prefer global `dw` on PATH; fall back to
+# `node $DW_BIN` for in-repo local development (where DW_BIN points at the
+# source bin script).
+if [ -n "$STAGED_FILES" ]; then
   CLAIMS_DIR="$CLAUDE_PROJECT_DIR/.dw/cache/agents/claims"
   if [ -d "$CLAIMS_DIR" ] && ls "$CLAIMS_DIR"/*.json >/dev/null 2>&1; then
-    OUT_OF_SCOPE=$(STAGED="$STAGED_FILES" node -e "
-      const fs = require('fs');
-      const path = require('path');
-      (async () => {
-        const { listClaims } = await import('$CLAUDE_PROJECT_DIR/src/lib/agent-claim.mjs');
-        const { pathMatchesScope } = await import('$CLAUDE_PROJECT_DIR/src/lib/agent-conflict.mjs');
-        const claims = listClaims(process.env.CLAUDE_PROJECT_DIR || '$CLAUDE_PROJECT_DIR').filter(c => c._live_status === 'created' || c._live_status === 'active');
-        if (claims.length === 0) return;
-        const allScopes = claims.flatMap(c => c.write_scope);
-        const staged = (process.env.STAGED || '').split(/\r?\n/).filter(Boolean);
-        const outside = staged.filter(f => !pathMatchesScope(f, allScopes));
-        if (outside.length > 0) {
-          console.log('Files NOT in any active claim write_scope:');
-          for (const f of outside.slice(0, 10)) console.log('  ' + f);
-          if (outside.length > 10) console.log('  ... +' + (outside.length - 10) + ' more');
-        }
-      })().catch(e => { /* fail-graceful */ });
-    " 2>/dev/null || true)
+    if command -v dw >/dev/null 2>&1; then
+      OUT_OF_SCOPE=$(echo "$STAGED_FILES" | dw agent check-staged --stdin 2>/dev/null || true)
+    elif [ -f "$DW_BIN" ] && command -v node >/dev/null 2>&1; then
+      # Local dev fallback: in-repo dw-kit work where global `dw` not on PATH
+      OUT_OF_SCOPE=$(echo "$STAGED_FILES" | node "$DW_BIN" agent check-staged --stdin 2>/dev/null || true)
+    else
+      OUT_OF_SCOPE=""
+    fi
     if [ -n "$OUT_OF_SCOPE" ]; then
       echo "⚠️  Agent OS (ADR-0009 R2-2): post-hoc claim check" >&2
       echo "$OUT_OF_SCOPE" >&2

package/.dw/core/schemas/agent-claim.schema.json

@@ -114,7 +114,27 @@
     },
     "worktree_path": {
       "type": "string",
-      "description": "If agent operates in a git worktree per R2-3, the worktree path. .dw/cache/worktrees/{agent-id}/"
+      "description": "Absolute path to the git worktree this agent operates in (issue #15). dw does NOT create or delete this directory — the caller harness owns lifecycle (`git worktree add` / `git worktree remove`). When two claims declare distinct worktree_path values, dw conflict detection skips write_scope comparison between them (physical isolation). One or both null → conservative; assume overlap."
+    },
+    "original_lease_expires": {
+      "type": "string",
+      "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z$",
+      "description": "Issue #15: lease_expires at claim creation time (immutable). Renewals do NOT change this — caps total lease window via max_renewals."
+    },
+    "renewed_at": {
+      "type": "string",
+      "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z$",
+      "description": "Issue #15: timestamp of last `dw agent renew` call. Stamped on each renewal; previous value overwritten."
+    },
+    "renewal_count": {
+      "type": "integer",
+      "minimum": 0,
+      "description": "Issue #15: number of times this claim has been renewed. Bounded by MAX_RENEWALS (default 3) to prevent unbounded lease compounding."
+    },
+    "previous_lease_expires": {
+      "type": "string",
+      "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z$",
+      "description": "Issue #15: lease_expires value immediately before the most recent renewal. Provides self-describing renewal history without depending on events.jsonl."
     }
   },
   "allOf": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dw-kit",
-  "version": "1.7.0-rc.1",
+  "version": "1.7.0-rc.2",
   "description": "AI development workflow toolkit — structured, quality-assured, team-ready. From requirements to dashboard.",
   "type": "module",
   "bin": {

package/src/cli.mjs

@@ -196,7 +196,7 @@ export function run(argv) {
 
   const agentCmd = program
     .command('agent')
-    .description('Agent OS multi-agent orchestration (ADR-0009): claim · release · claims · reports · conflicts');
+    .description('Agent OS multi-agent orchestration (ADR-0009): claim · release · renew · expire · claims · reports · conflicts · check-staged · verify');
 
   agentCmd
     .command('claim <task-id>')
@@ -224,6 +224,15 @@ export function run(argv) {
       await agentReleaseCommand(claimId, opts);
     });
 
+  agentCmd
+    .command('renew <claim-id>')
+    .description('Extend lease on an active claim WITHOUT changing claim_id (preserves audit continuity vs expire+reclaim). Capped at 3 renewals (issue #15)')
+    .option('-l, --lease <duration>', 'New lease window (e.g. 30m, 1h, 4h)', '1h')
+    .action(async (claimId, opts) => {
+      const { agentRenewCommand } = await import('./commands/agent-claim.mjs');
+      await agentRenewCommand(claimId, opts);
+    });
+
   agentCmd
     .command('expire <claim-id>')
     .description('Mark a claim as expired or invalidated (orchestrator action)')
@@ -265,6 +274,25 @@ export function run(argv) {
       await agentConflictsCommand(opts);
     });
 
+  agentCmd
+    .command('check-staged [files...]')
+    .description('Check staged files against active claim write_scopes (R2-2 cooperative; used by pre-commit-gate hook). Always exits 0; warning on stdout.')
+    .option('--stdin', 'Read file list from stdin (one path per line) instead of positional args')
+    .action(async (files, opts) => {
+      const { agentCheckStagedCommand } = await import('./commands/agent-check-staged.mjs');
+      await agentCheckStagedCommand(files, opts);
+    });
+
+  agentCmd
+    .command('verify <task-id>')
+    .description('Check events.jsonl well-formedness for a task (detects malformed JSON lines; exits 1 if any). Note: not full tamper-evidence — use git log for that.')
+    .option('-v, --verbose', 'Show raw line content for malformed entries')
+    .option('--no-strict', 'Report malformed lines but always exit 0')
+    .action(async (taskId, opts) => {
+      const { agentVerifyCommand } = await import('./commands/agent-verify.mjs');
+      await agentVerifyCommand(taskId, opts);
+    });
+
   const goalCmd = program
     .command('goal')
     .description('Goals Management Layer (ADR-0010): strategic layer above tasks. new · show · link · summary · portfolio · lint · bump · delete · view');

package/src/commands/agent-check-staged.mjs

@@ -0,0 +1,63 @@
+import { createInterface } from 'node:readline';
+import { listClaims } from '../lib/agent-claim.mjs';
+import { pathMatchesScope } from '../lib/agent-conflict.mjs';
+
+/**
+ * `dw agent check-staged <files...>` or `dw agent check-staged --stdin`
+ *
+ * Issue #13 Bug 3: pre-commit-gate.sh R2-2 block used inline `node -e` with
+ * `import('$CLAUDE_PROJECT_DIR/src/lib/agent-claim.mjs')` — dead code in
+ * consumer projects (cwd-relative path resolves to non-existent file) and
+ * exposed path-injection via shell variable substitution into JS string.
+ * This subcommand replaces the inline JS — hooks now invoke `dw agent
+ * check-staged --stdin` cleanly via the installed binary.
+ *
+ * Output contract (cooperative-only per ADR-0009 R2):
+ *   - stdout: warning text if any staged files fall outside active claim
+ *             write_scopes; empty otherwise
+ *   - exit code: ALWAYS 0 (cooperative protocol — never blocks commits)
+ *
+ * Hook detects out-of-scope by checking stdout is non-empty.
+ */
+export async function agentCheckStagedCommand(files, opts = {}) {
+  const rootDir = process.cwd();
+  let inputFiles = Array.isArray(files) ? [...files] : [];
+
+  if (opts.stdin) {
+    const rl = createInterface({ input: process.stdin, crlfDelay: Infinity });
+    for await (const line of rl) {
+      const trimmed = line.trim();
+      if (trimmed) inputFiles.push(trimmed);
+    }
+  }
+
+  // No files to check → silent success
+  if (inputFiles.length === 0) {
+    process.exit(0);
+    return;
+  }
+
+  // No active claims → nothing to check against; silent success
+  const claims = listClaims(rootDir).filter(
+    (c) => c._live_status === 'created' || c._live_status === 'active'
+  );
+  if (claims.length === 0) {
+    process.exit(0);
+    return;
+  }
+
+  // Aggregate all active write_scopes. pathMatchesScope normalizes separators
+  // internally (Bug 2 fix) so legacy backslash claims still match correctly.
+  const allScopes = claims.flatMap((c) => c.write_scope);
+  const outside = inputFiles.filter((f) => !pathMatchesScope(f, allScopes));
+
+  if (outside.length > 0) {
+    console.log('Files NOT in any active claim write_scope:');
+    for (const f of outside.slice(0, 10)) console.log('  ' + f);
+    if (outside.length > 10) console.log('  ... +' + (outside.length - 10) + ' more');
+    // Black-bot C-4: exit 0 here intentional (cooperative protocol; hook detects
+    // out-of-scope via non-empty stdout, not exit code). Single exit at end below.
+  }
+
+  process.exit(0);
+}

package/src/commands/agent-claim.mjs

@@ -2,9 +2,10 @@ import chalk from 'chalk';
 import { existsSync, openSync, closeSync, mkdirSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
 import { randomBytes } from 'node:crypto';
-import { createClaim, persistClaim, validateClaim, transitionClaim, loadClaim, listClaims } from '../lib/agent-claim.mjs';
+import { createClaim, persistClaim, validateClaim, transitionClaim, loadClaim, listClaims, renewClaim, computeEffectiveExpiry, MAX_RENEWALS } from '../lib/agent-claim.mjs';
 import { logAgentEvent } from '../lib/agent-events.mjs';
-import { scopesOverlap } from '../lib/agent-conflict.mjs';
+import { scopesOverlap, normalizeSep, pathMatchesScope, claimsShareFilesystem } from '../lib/agent-conflict.mjs';
+import { spawnSync } from 'node:child_process';
 import { logEvent as logTelemetry } from '../lib/telemetry.mjs';
 
 const LOCK_DIR = '.dw/cache/agents';
@@ -71,8 +72,11 @@ export async function agentClaimCommand(taskId, opts = {}) {
   }
 
   const role = opts.role || 'worker';
-  const writeScope = parseList(opts.write);
-  const readScope = parseList(opts.read);
+  // Issue #13 Bug 2: normalize Windows backslash → forward slash at claim creation
+  // so persisted JSON is always forward-slash. Legacy claims handled via runtime
+  // normalization in pathMatchesScope.
+  const writeScope = parseList(opts.write).map(normalizeSep);
+  const readScope = parseList(opts.read).map(normalizeSep);
   const leaseSeconds = parseLease(opts.lease || '1h');
 
   if (role !== 'reader' && writeScope.length === 0) {
@@ -124,7 +128,10 @@ export async function agentClaimCommand(taskId, opts = {}) {
   } finally {
     releaseClaimLock(lock);
   }
-  logAgentEvent(taskId, {
+  // Issue #14 Bug 3: check logAgentEvent return; warn on stderr if audit log write failed.
+  // Claim succeeds (write to .dw/cache/.../claims/*.json already done above); only the audit
+  // entry is at risk (Windows file lock, full disk, permission).
+  const auditResult = logAgentEvent(taskId, {
     event: 'claim_created',
     claim_id: claim.claim_id,
     agent_id: agentId,
@@ -134,7 +141,11 @@ export async function agentClaimCommand(taskId, opts = {}) {
     write_scope: writeScope,
     lease_expires: claim.lease_expires,
   }, rootDir);
-  logTelemetry({ event: 'agent', action: 'claim.create', name: taskId, vendor, role }, rootDir);
+  if (!auditResult.ok) {
+    console.error(chalk.yellow(`⚠  Warning: failed to write claim_created to events.jsonl: ${auditResult.error?.message || 'unknown'}`));
+    console.error(chalk.dim('   Claim was created but audit log has a gap.'));
+  }
+  logTelemetry({ event: 'agent', action: 'claim.create', name: taskId, vendor, role, audit_ok: auditResult.ok }, rootDir);
 
   console.log();
   console.log(chalk.green('✓') + ` Claim created: ${chalk.cyan(claim.claim_id)}`);
@@ -149,6 +160,44 @@ export async function agentClaimCommand(taskId, opts = {}) {
   console.log();
 }
 
+// Issue #14 Gap fix — write_reconciled event source. Enumerate staged files (or fall back to
+// HEAD diff if staging is empty per black-bot H-5) and flag any outside the claim's write_scope.
+// Uses spawnSync with 2s timeout (black-bot H-6: previous proposal had execSync 5s — too long
+// on large repos with network FS).
+function computeWriteReconcile(rootDir, writeScope) {
+  const args = ['diff', '--name-only', '--cached'];
+  let result;
+  try {
+    result = spawnSync('git', args, { cwd: rootDir, encoding: 'utf-8', timeout: 2000, shell: false });
+  } catch {
+    return { method: 'none', files: [], outOfScope: [] };
+  }
+  if (result.error || result.status !== 0) {
+    return { method: 'none', files: [], outOfScope: [] };
+  }
+  let files = (result.stdout || '').split('\n').map((f) => f.trim()).filter(Boolean);
+  let method = 'git-staged';
+  if (files.length === 0) {
+    // Black-bot H-5: staging empty (likely agent committed before release) → try HEAD diff
+    let headResult;
+    try {
+      headResult = spawnSync('git', ['diff', 'HEAD', '--name-only'], {
+        cwd: rootDir, encoding: 'utf-8', timeout: 2000, shell: false,
+      });
+    } catch {
+      return { method: 'none', files: [], outOfScope: [] };
+    }
+    if (headResult.error || headResult.status !== 0) {
+      return { method: 'none', files: [], outOfScope: [] };
+    }
+    files = (headResult.stdout || '').split('\n').map((f) => f.trim()).filter(Boolean);
+    if (files.length > 0) method = 'git-head-diff';
+    else return { method: 'none', files: [], outOfScope: [] };
+  }
+  const outOfScope = files.filter((f) => !pathMatchesScope(f, writeScope));
+  return { method, files, outOfScope };
+}
+
 function checkOverlapAgainstActive(newClaim, rootDir) {
   // Reviewer Warning #3: write_scope collisions must be detected REPO-WIDE,
   // not just within the same task. Subtask overlap remains task-scoped (IDs only
@@ -164,10 +213,14 @@ function checkOverlapAgainstActive(newClaim, rootDir) {
     const subtaskOverlap = sameTask
       ? newClaim.subtasks.filter((s) => e.subtasks.includes(s))
       : [];
+    // Issue #15: skip write_scope comparison when claims operate in distinct worktrees
+    const worktreeIsolated = !claimsShareFilesystem(newClaim, e);
     const writeOverlap = [];
-    for (const pa of newClaim.write_scope) {
-      for (const pb of e.write_scope) {
-        if (scopesOverlap(pa, pb)) writeOverlap.push({ new: pa, existing: pb });
+    if (!worktreeIsolated) {
+      for (const pa of newClaim.write_scope) {
+        for (const pb of e.write_scope) {
+          if (scopesOverlap(pa, pb)) writeOverlap.push({ new: pa, existing: pb });
+        }
       }
     }
     if (subtaskOverlap.length || writeOverlap.length) {
@@ -175,6 +228,7 @@ function checkOverlapAgainstActive(newClaim, rootDir) {
       if (subtaskOverlap.length) reasons.push(`subtasks ${subtaskOverlap.join(',')}`);
       if (writeOverlap.length) reasons.push(`write scope ${writeOverlap.map((o) => o.existing).join(',')}`);
       if (!sameTask) reasons.push(`(cross-task: ${e.task_id})`);
+      if (worktreeIsolated) reasons.push('(worktree-isolated, write scope ignored)');
       conflicts.push({ claim_id: e.claim_id, agent_id: e.agent.id, reason: reasons.join('; ') });
     }
   }
@@ -197,13 +251,36 @@ export async function agentReleaseCommand(claimId, opts = {}) {
     console.error(chalk.red(`✗ Cannot release: ${result.reason}`));
     process.exit(1);
   }
-  logAgentEvent(claim.task_id, {
+  // Issue #14 Gap fix — write_reconciled: enumerate actual staged files at release time
+  // and flag any that fall outside this claim's write_scope.
+  // Black-bot H-5 fix: fall back to `git diff HEAD` when staging empty (agent committed first).
+  // Black-bot H-6 fix: spawnSync with shell:false + 2s timeout (was execSync 5s).
+  const reconcile = computeWriteReconcile(rootDir, claim.write_scope);
+  if (reconcile.method !== 'none') {
+    const recResult = logAgentEvent(claim.task_id, {
+      event: 'write_reconciled',
+      claim_id: claimId,
+      agent_id: claim.agent.id,
+      staged_files: reconcile.files,
+      out_of_scope: reconcile.outOfScope,
+      reconcile_method: reconcile.method,
+    }, rootDir);
+    if (!recResult.ok) {
+      console.error(chalk.yellow(`⚠  Warning: failed to write write_reconciled to events.jsonl: ${recResult.error?.message || 'unknown'}`));
+    }
+  }
+
+  // Issue #14 Bug 3: check audit log write for claim_released
+  const releaseAudit = logAgentEvent(claim.task_id, {
     event: 'claim_released',
     claim_id: claimId,
     agent_id: claim.agent.id,
     reason: opts.reason || 'clean exit',
   }, rootDir);
-  logTelemetry({ event: 'agent', action: 'claim.release', name: claim.task_id }, rootDir);
+  if (!releaseAudit.ok) {
+    console.error(chalk.yellow(`⚠  Warning: failed to write claim_released to events.jsonl: ${releaseAudit.error?.message || 'unknown'}`));
+  }
+  logTelemetry({ event: 'agent', action: 'claim.release', name: claim.task_id, audit_ok: releaseAudit.ok }, rootDir);
   console.log(chalk.green('✓') + ` Released: ${claimId}`);
 }
 
@@ -224,12 +301,87 @@ export async function agentExpireCommand(claimId, opts = {}) {
     console.error(chalk.red(`✗ Cannot ${status}: ${result.reason}`));
     process.exit(1);
   }
-  logAgentEvent(claim.task_id, {
+  // Issue #14 Bug 3: check audit log write
+  const expireAudit = logAgentEvent(claim.task_id, {
     event: status === 'invalidated' ? 'claim_invalidated' : 'claim_expired',
     claim_id: claimId,
     agent_id: claim.agent.id,
     reason: opts.reason || 'manual',
   }, rootDir);
-  logTelemetry({ event: 'agent', action: `claim.${status}`, name: claim.task_id }, rootDir);
+  if (!expireAudit.ok) {
+    console.error(chalk.yellow(`⚠  Warning: failed to write claim_${status} to events.jsonl: ${expireAudit.error?.message || 'unknown'}`));
+  }
+  logTelemetry({ event: 'agent', action: `claim.${status}`, name: claim.task_id, audit_ok: expireAudit.ok }, rootDir);
   console.log(chalk.yellow(`⚠ ${status}: ${claimId}`));
 }
+
+// Issue #15 Gap fix — dw agent renew <claim-id> [--lease <dur>]
+// Extends lease in-place without invalidating claim_id (preserves events.jsonl audit continuity).
+// Acquires claim.lock (black-bot C-2: avoid TOCTOU vs concurrent claim/release/renew).
+export async function agentRenewCommand(claimId, opts = {}) {
+  const rootDir = process.cwd();
+  if (!claimId) {
+    console.error(chalk.red('✗ Claim ID required: dw agent renew <claim-id> --lease <dur>'));
+    process.exit(1);
+  }
+  const extensionSeconds = parseLease(opts.lease || '1h');
+  if (extensionSeconds < 60 || extensionSeconds > 86400) {
+    console.error(chalk.red(`✗ Invalid --lease ${opts.lease}: must be 60s..24h`));
+    process.exit(1);
+  }
+
+  const lock = acquireClaimLock(rootDir);
+  if (!lock) {
+    console.error(chalk.red(`✗ Could not acquire claim lock within ${LOCK_TIMEOUT_MS}ms.`));
+    process.exit(1);
+  }
+  let result;
+  let preClaim;
+  try {
+    preClaim = loadClaim(claimId, rootDir);
+    if (preClaim) {
+      // Warn near-expiry / already-expired for operator awareness
+      const remaining = computeEffectiveExpiry(preClaim) - Date.now();
+      if (remaining <= 0) {
+        console.error(chalk.yellow(`⚠  Claim lease was already expired at renewal time (wall-clock check); rejecting per claim safety.`));
+      } else if (remaining < 10 * 60 * 1000) {
+        console.error(chalk.yellow(`⚠  Lease had < 10 min remaining (${Math.floor(remaining / 1000)}s) before renewal.`));
+      }
+    }
+    result = renewClaim(claimId, extensionSeconds, rootDir);
+  } finally {
+    releaseClaimLock(lock);
+  }
+
+  if (!result.ok) {
+    console.error(chalk.red(`✗ Cannot renew: ${result.reason}`));
+    process.exit(1);
+  }
+
+  const auditResult = logAgentEvent(result.claim.task_id, {
+    event: 'claim_renewed',
+    claim_id: claimId,
+    agent_id: result.claim.agent.id,
+    previous_lease_expires: result.claim.previous_lease_expires,
+    new_lease_expires: result.claim.lease_expires,
+    extension_seconds: extensionSeconds,
+    renewal_count: result.claim.renewal_count,
+  }, rootDir);
+  if (!auditResult.ok) {
+    console.error(chalk.yellow(`⚠  Warning: failed to write claim_renewed to events.jsonl: ${auditResult.error?.message || 'unknown'}`));
+  }
+  logTelemetry({
+    event: 'agent', action: 'claim.renew', name: result.claim.task_id,
+    renewal_count: result.claim.renewal_count, max_renewals: MAX_RENEWALS,
+    audit_ok: auditResult.ok,
+  }, rootDir);
+
+  console.log(chalk.green('✓') + ` Renewed: ${chalk.cyan(claimId)}`);
+  console.log(chalk.dim(`  previous lease_expires: ${result.claim.previous_lease_expires}`));
+  console.log(chalk.dim(`  new lease_expires:      ${result.claim.lease_expires}`));
+  console.log(chalk.dim(`  extension:              ${extensionSeconds}s`));
+  console.log(chalk.dim(`  renewal_count:          ${result.claim.renewal_count} / ${MAX_RENEWALS}`));
+  if (result.claim.renewal_count >= MAX_RENEWALS) {
+    console.log(chalk.yellow(`  ⚠  Max renewals reached. Next renewal will be rejected — release this claim and reclaim if you need more time.`));
+  }
+}

package/src/commands/agent-inspect.mjs

@@ -114,6 +114,10 @@ export async function agentConflictsCommand(opts = {}) {
     for (const w of c.write_overlap) {
       console.log(chalk.red(`  write overlap: "${w.a}" ↔ "${w.b}"`));
     }
+    // Issue #15 black-bot H-2: explain when write_overlap is empty due to worktree isolation
+    if (c.worktree_isolated && c.write_overlap.length === 0) {
+      console.log(chalk.dim('  note: write scopes skipped (claims operate in distinct worktrees — physically isolated)'));
+    }
     console.log();
   }
 

package/src/commands/agent-verify.mjs

@@ -0,0 +1,75 @@
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'node:fs';
+import { eventsFile, readEvents } from '../lib/agent-events.mjs';
+import { logEvent } from '../lib/telemetry.mjs';
+
+/**
+ * `dw agent verify <task-id>` — well-formedness check on events.jsonl.
+ *
+ * IMPORTANT (black-bot H-7 honesty): this command detects ONLY malformed JSON lines.
+ * It does NOT detect:
+ *   - Deleted lines (undetectable without sequence numbers / hash chain)
+ *   - Reordered lines with valid JSON
+ *   - In-place edits that produce valid but different JSON
+ *
+ * For stronger tamper-evidence, rely on git: `events.jsonl` is committed, so
+ * `git log --follow -- .dw/tasks/<task>/events.jsonl` reveals all modifications.
+ * Hash-chain integrity was explicitly deferred per lean mandate (ADR-0001).
+ */
+export async function agentVerifyCommand(taskId, opts = {}) {
+  const rootDir = process.cwd();
+
+  if (!taskId) {
+    console.error(chalk.red('✗ Task ID required: dw agent verify <task-id>'));
+    process.exit(1);
+  }
+
+  const file = eventsFile(taskId, rootDir);
+  if (!existsSync(file)) {
+    console.log(chalk.dim(`  No events.jsonl for task ${taskId}`));
+    return;
+  }
+
+  const allLines = readFileSync(file, 'utf8').split('\n').filter(Boolean);
+  const parsed = readEvents(taskId, rootDir, { strict: true });
+
+  const malformed = parsed.filter((e) => e._malformed);
+  const valid = parsed.filter((e) => !e._malformed);
+
+  logEvent({
+    event: 'agent',
+    action: 'verify',
+    name: taskId,
+    total: allLines.length,
+    valid: valid.length,
+    malformed: malformed.length,
+  }, rootDir);
+
+  console.log();
+  console.log(chalk.bold(`  events.jsonl — ${taskId}`));
+  console.log(chalk.dim(`  file: ${file}`));
+  console.log(chalk.dim(`  total lines: ${allLines.length}`));
+  console.log(chalk.dim(`  parsed ok:   ${valid.length}`));
+
+  if (malformed.length === 0) {
+    console.log(chalk.green('  ✓ All lines are valid JSON (well-formedness check passed)'));
+    console.log(chalk.dim('  Note: this is well-formedness, not tamper-evidence. Use'));
+    console.log(chalk.dim(`        \`git log --follow -- ${file.replace(rootDir, '').replace(/^[/\\]/, '')}\` for full history.`));
+    console.log();
+    return;
+  }
+
+  console.log(chalk.red(`  ✗ ${malformed.length} malformed line(s) detected:`));
+  console.log();
+  for (const m of malformed) {
+    console.log(chalk.red(`    line ${m._line}: ${m._error}`));
+    if (opts.verbose) console.log(chalk.dim(`      raw: ${m._raw.slice(0, 120)}${m._raw.length > 120 ? '…' : ''}`));
+  }
+  console.log();
+  console.log(chalk.dim('  Tip: `git log -- ' + file.replace(rootDir, '').replace(/^[/\\]/, '') + '` to inspect commit history.'));
+  console.log();
+
+  if (opts.strict !== false) {
+    process.exit(1);
+  }
+}

package/src/commands/task-watch.mjs

@@ -79,7 +79,9 @@ function ensureBrowserClaim(goalId, rootDir) {
   }, rootDir);
   persistClaim(claim, rootDir);
   browserClaims.set(goalId, claim.claim_id);
-  logAgentEvent(goalToTaskId(goalId), {
+  // Issue #14 Bug 3 + black-bot H-4: handle audit log write failure in HTTP context
+  // (no terminal to print to — use telemetry instead).
+  const auditResult = logAgentEvent(goalToTaskId(goalId), {
     event: 'claim_created',
     claim_id: claim.claim_id,
     agent: claim.agent,
@@ -87,6 +89,13 @@ function ensureBrowserClaim(goalId, rootDir) {
     write_scope: claim.write_scope,
     via: 'browser_implicit',
   }, rootDir);
+  if (!auditResult.ok) {
+    logEvent({
+      event: 'audit', action: 'write_failed',
+      context: 'browser_claim_created', goal_id: goalId,
+      error: String(auditResult.error?.message || 'unknown'),
+    }, rootDir);
+  }
   return claim.claim_id;
 }
 
@@ -113,12 +122,19 @@ function releaseBrowserClaim(goalId, rootDir, reason = 'browser closed') {
   if (!claimId) return null;
   try {
     transitionClaim(claimId, 'released', { reason }, rootDir);
-    logAgentEvent(goalToTaskId(goalId), {
+    const auditResult = logAgentEvent(goalToTaskId(goalId), {
       event: 'claim_released',
       claim_id: claimId,
       reason,
       via: 'browser_implicit',
     }, rootDir);
+    if (!auditResult.ok) {
+      logEvent({
+        event: 'audit', action: 'write_failed',
+        context: 'browser_claim_released', goal_id: goalId,
+        error: String(auditResult.error?.message || 'unknown'),
+      }, rootDir);
+    }
   } catch { /* claim already gone */ }
   browserClaims.delete(goalId);
   return claimId;

package/src/lib/agent-claim.mjs

@@ -78,11 +78,58 @@ export function createClaim({ taskId, agent, subtasks, writeScope = [], readScop
     lease_duration_seconds: leaseSeconds,
     status: 'created',
     created_at: created,
+    // Issue #15 black-bot H-3: immutable creation-time expiry caps unbounded renewal compounding
+    original_lease_expires: expires,
   };
   if (worktreePath) claim.worktree_path = worktreePath;
   return claim;
 }
 
+// Issue #15 Gap fix — extend lease in-place on active/created claim WITHOUT changing claim_id
+// (preserves audit continuity in events.jsonl). Caller MUST hold claim.lock per black-bot C-2.
+// Returns same shape as transitionClaim for consistency.
+export const MAX_RENEWALS = 3;
+
+export function renewClaim(claimId, extensionSeconds, rootDir = process.cwd()) {
+  const claim = loadClaim(claimId, rootDir);
+  if (!claim) return { ok: false, reason: 'not-found' };
+
+  // Black-bot C-3: check wall-clock expiry, not just persisted status. A claim with
+  // status="active" but elapsed lease should not be silently renewed.
+  if (claim.status === 'released' || claim.status === 'expired' || claim.status === 'invalidated') {
+    return { ok: false, reason: `invalid-state: cannot renew ${claim.status} claim` };
+  }
+  if (computeEffectiveExpiry(claim) < Date.now()) {
+    return { ok: false, reason: 'already-expired-by-wall-clock' };
+  }
+
+  if (!Number.isFinite(extensionSeconds) || extensionSeconds < 60 || extensionSeconds > 86400) {
+    return { ok: false, reason: 'invalid-duration: must be 60–86400 seconds' };
+  }
+
+  // Black-bot H-3 cap: prevent unbounded lease compounding
+  const renewalCount = claim.renewal_count || 0;
+  if (renewalCount >= MAX_RENEWALS) {
+    return { ok: false, reason: `max-renewals-exceeded: ${renewalCount}/${MAX_RENEWALS}` };
+  }
+
+  // Black-bot H-4: preserve audit history on claim file itself
+  claim.previous_lease_expires = claim.lease_expires;
+  claim.renewed_at = nowIsoUtc();
+  claim.renewal_count = renewalCount + 1;
+  claim.lease_expires = new Date(Date.now() + extensionSeconds * 1000).toISOString().replace(/\.\d+Z$/, 'Z');
+  claim.lease_duration_seconds = extensionSeconds;
+
+  // Black-bot M-2: validate after mutation to catch programmatic misuse
+  const v = validateClaim(claim, rootDir);
+  if (!v.ok) {
+    return { ok: false, reason: 'schema-invalid: ' + (v.errors || []).map((e) => e.message).join(', ') };
+  }
+
+  persistClaim(claim, rootDir);
+  return { ok: true, claim };
+}
+
 export function persistClaim(claim, rootDir = process.cwd()) {
   const dir = claimsDir(rootDir);
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });

package/src/lib/agent-conflict.mjs

@@ -1,10 +1,53 @@
 import { listClaims, loadClaim, computeEffectiveExpiry } from './agent-claim.mjs';
+import { resolve } from 'node:path';
+import { realpathSync } from 'node:fs';
+
+// Issue #13 Bug 2: normalize Windows backslash → forward slash at caller boundary
+// (NOT inside globToRegex — keeps globToRegex's single-responsibility intact).
+// Applied at: scopesOverlap entry, pathMatchesScope per-pattern AND per-path,
+// agent-claim writeScope parse time (in agentClaimCommand).
+export function normalizeSep(s) {
+  if (s == null) return s;
+  return String(s).replace(/\\/g, '/');
+}
+
+// Issue #15 black-bot C-1 fix: full path canonicalization for worktree comparison.
+// normalizeSep alone misses trailing slash, relative paths, Windows case-insensitivity,
+// and symlinks. Two claims in the same physical worktree with different path
+// representations would bypass the isolation guard otherwise.
+export function canonicalizeWorktreePath(p) {
+  if (p == null) return null;
+  let s = normalizeSep(String(p));
+  // Strip trailing slashes (but keep root '/')
+  s = s.replace(/\/+$/, '') || '/';
+  // Resolve relative paths to absolute
+  try { s = normalizeSep(resolve(s)); } catch { /* keep s */ }
+  // Best-effort symlink resolution (path may not exist — that's fine)
+  try { s = normalizeSep(realpathSync(s)); } catch { /* keep resolved value */ }
+  // Windows: NTFS case-insensitive → lowercase
+  if (process.platform === 'win32') s = s.toLowerCase();
+  return s;
+}
+
+// Issue #15 Bug fix — worktree-aware overlap.
+// Two claims in distinct non-null worktrees are physically isolated → no scope overlap.
+// One or both null (main checkout) → conservative; assume overlap.
+export function claimsShareFilesystem(claimA, claimB) {
+  const wa = canonicalizeWorktreePath(claimA && claimA.worktree_path);
+  const wb = canonicalizeWorktreePath(claimB && claimB.worktree_path);
+  if (wa !== null && wb !== null && wa !== wb) return false;
+  return true;
+}
 
 // Glob → RegExp following gitignore-style semantics:
 //   `**`     matches zero-or-more path segments (including empty)
 //   `*`      matches anything within a segment (no `/`)
 //   `?`      matches single char (no `/`)
 // Behaviour validated by reviewer Critical #1: src/**/*.js MUST match src/x.js.
+//
+// Note (issue #13 Bug 2 / black-bot H-8): globToRegex stays pure — it does NOT
+// normalize separators. Callers (pathMatchesScope, scopesOverlap, etc.) are
+// responsible for normalizing inputs before invoking globToRegex.
 export function globToRegex(glob) {
   let pattern = '';
   for (let i = 0; i < glob.length; i++) {
@@ -41,40 +84,137 @@ export function globToRegex(glob) {
   return new RegExp(`^${pattern}$`);
 }
 
+// Issue #13 Bug 2 + H-5 + H-7: normalize BOTH path AND each pattern.
+// This single location covers all callers (detectOutOfScopeEdits, check-staged hook,
+// programmatic agentCheckStagedCommand).
 export function pathMatchesScope(path, scope) {
+  const np = normalizeSep(path);
   for (const pattern of scope) {
-    if (globToRegex(pattern).test(path)) return true;
+    const npattern = normalizeSep(pattern);
+    if (globToRegex(npattern).test(np)) return true;
   }
   return false;
 }
 
-// Two globs/paths overlap if there exists a concrete path matching both.
-// We approximate by:
-//   - exact string equality
-//   - exact path matches a glob in the other set
-//   - both contain wildcards: try a small biased sample set at depths 0/1/2
+// Issue #13 Bug 1: Two globs/paths overlap if there exists a concrete path
+// matching both. Previous implementation used a 3-sample heuristic which
+// produced false negatives (e.g. `a/*/x.js` vs `a/y/*.js` share `a/y/x.js`
+// but neither's sample set generated that path).
+//
+// Replaced with segment-by-segment intersection (memoized + depth-guarded
+// per black-bot C-1). For glob-vs-glob single-segment subcases, segmentMeet
+// uses a heuristic candidate that the outer regex test validates (black-bot
+// C-2 — honest framing: "heuristic-but-validated", not pure deterministic).
 export function scopesOverlap(a, b) {
+  a = normalizeSep(a);
+  b = normalizeSep(b);
   if (a === b) return true;
+
   const aHasGlob = /[*?]/.test(a);
   const bHasGlob = /[*?]/.test(b);
   const ra = globToRegex(a);
   const rb = globToRegex(b);
 
-  // Concrete path vs glob: test the concrete one against the glob, both ways.
-  if (!aHasGlob && bHasGlob) return rb.test(a);
-  if (aHasGlob && !bHasGlob) return ra.test(b);
+  if (!aHasGlob && !bHasGlob) return false; // both literal + non-equal
+  if (!aHasGlob) return rb.test(a);
+  if (!bHasGlob) return ra.test(b);
+
+  // Both globs — segment intersection
+  const candidate = globIntersectCandidate(a.split('/'), b.split('/'));
+  if (candidate === null) return false;
+  return ra.test(candidate) && rb.test(candidate);
+}
+
+// Bound recursion depth on degenerate patterns (e.g. `**/**/**/**` chains).
+// Returning null on guard trip means "no candidate found" — outer scopesOverlap
+// returns false (cooperative fallback; never silent stack overflow).
+const MAX_INTERSECT_DEPTH = 256;
+
+export function globIntersectCandidate(segsA, segsB) {
+  return _intersect(segsA, 0, segsB, 0, new Map(), 0);
+}
+
+function _intersect(segsA, iA, segsB, iB, memo, depth) {
+  if (depth > MAX_INTERSECT_DEPTH) return null;
+  const key = iA + '-' + iB;
+  if (memo.has(key)) return memo.get(key);
+
+  const doneA = iA >= segsA.length;
+  const doneB = iB >= segsB.length;
+
+  if (doneA && doneB) { memo.set(key, ''); return ''; }
 
-  // Both globs — synthesise candidate concrete paths and test against both.
-  const samples = new Set();
-  for (const g of [a, b]) {
-    samples.add(g.replace(/\*\*\//g, '').replace(/\*\*/g, '').replace(/\*/g, 'X').replace(/\?/g, 'Y'));
-    samples.add(g.replace(/\*\*\//g, 'd/').replace(/\*\*/g, 'd').replace(/\*/g, 'X').replace(/\?/g, 'Y'));
-    samples.add(g.replace(/\*\*\//g, 'd/e/').replace(/\*\*/g, 'd/e').replace(/\*/g, 'X').replace(/\?/g, 'Y'));
+  const sA = doneA ? null : segsA[iA];
+  const sB = doneB ? null : segsB[iB];
+
+  if (doneA) {
+    const v = sB === '**' ? _intersect(segsA, iA, segsB, iB + 1, memo, depth + 1) : null;
+    memo.set(key, v); return v;
   }
-  for (const s of samples) {
-    if (ra.test(s) && rb.test(s)) return true;
+  if (doneB) {
+    const v = sA === '**' ? _intersect(segsA, iA + 1, segsB, iB, memo, depth + 1) : null;
+    memo.set(key, v); return v;
   }
-  return false;
+
+  if (sA === '**' && sB === '**') {
+    const tryA = _intersect(segsA, iA + 1, segsB, iB, memo, depth + 1);
+    if (tryA !== null) { memo.set(key, tryA); return tryA; }
+    const tryB = _intersect(segsA, iA, segsB, iB + 1, memo, depth + 1);
+    memo.set(key, tryB); return tryB;
+  }
+
+  if (sA === '**') {
+    const skip = _intersect(segsA, iA + 1, segsB, iB, memo, depth + 1);
+    if (skip !== null) { memo.set(key, skip); return skip; }
+    const consume = _intersect(segsA, iA, segsB, iB + 1, memo, depth + 1);
+    if (consume !== null) {
+      const concrete = concreteSegment(sB);
+      const result = concrete + (consume === '' ? '' : '/' + consume);
+      memo.set(key, result); return result;
+    }
+    memo.set(key, null); return null;
+  }
+  if (sB === '**') {
+    const skip = _intersect(segsA, iA, segsB, iB + 1, memo, depth + 1);
+    if (skip !== null) { memo.set(key, skip); return skip; }
+    const consume = _intersect(segsA, iA + 1, segsB, iB, memo, depth + 1);
+    if (consume !== null) {
+      const concrete = concreteSegment(sA);
+      const result = concrete + (consume === '' ? '' : '/' + consume);
+      memo.set(key, result); return result;
+    }
+    memo.set(key, null); return null;
+  }
+
+  const seg = segmentMeet(sA, sB);
+  if (seg === null) { memo.set(key, null); return null; }
+  const rest = _intersect(segsA, iA + 1, segsB, iB + 1, memo, depth + 1);
+  if (rest === null) { memo.set(key, null); return null; }
+  const result = rest === '' ? seg : seg + '/' + rest;
+  memo.set(key, result); return result;
+}
+
+// Returns concrete string satisfying both single-segment patterns, or null.
+// For glob-vs-glob: heuristic candidate (outer scopesOverlap validates via
+// regex.test on both). Honest framing per black-bot C-2.
+function segmentMeet(sA, sB) {
+  const aGlob = /[*?]/.test(sA);
+  const bGlob = /[*?]/.test(sB);
+  if (!aGlob && !bGlob) return sA === sB ? sA : null;
+  if (!aGlob) return globToRegex(sB).test(sA) ? sA : null;
+  if (!bGlob) return globToRegex(sA).test(sB) ? sB : null;
+  // Both segments wildcard: try candidate from sA; if mismatch, try sB; else 'x'.
+  // Outer validator catches incorrect candidates.
+  const candA = concreteSegment(sA);
+  if (globToRegex(sB).test(candA)) return candA;
+  const candB = concreteSegment(sB);
+  if (globToRegex(sA).test(candB)) return candB;
+  return 'x';
+}
+
+function concreteSegment(seg) {
+  const replaced = seg.replace(/\*+/g, 'x').replace(/\?/g, 'y');
+  return replaced || 'x';
 }
 
 export function detectClaimOverlaps(rootDir = process.cwd(), { taskId, includeAllTasks = false } = {}) {
@@ -106,10 +246,15 @@ export function detectClaimOverlaps(rootDir = process.cwd(), { taskId, includeAl
       const subtaskOverlap = a.task_id === b.task_id
         ? a.subtasks.filter((s) => b.subtasks.includes(s))
         : [];
+      // Issue #15: skip write_scope comparison when claims operate in distinct worktrees
+      // (physical isolation). Subtask overlap stays — that's semantic, not filesystem-based.
+      const worktreeIsolated = !claimsShareFilesystem(a, b);
       const writeOverlap = [];
-      for (const pa of a.write_scope) {
-        for (const pb of b.write_scope) {
-          if (scopesOverlap(pa, pb)) writeOverlap.push({ a: pa, b: pb });
+      if (!worktreeIsolated) {
+        for (const pa of a.write_scope) {
+          for (const pb of b.write_scope) {
+            if (scopesOverlap(pa, pb)) writeOverlap.push({ a: pa, b: pb });
+          }
         }
       }
 
@@ -122,6 +267,7 @@ export function detectClaimOverlaps(rootDir = process.cwd(), { taskId, includeAl
           task_id: a.task_id === b.task_id ? a.task_id : `${a.task_id},${b.task_id}`,
           subtask_overlap: subtaskOverlap,
           write_overlap: writeOverlap,
+          worktree_isolated: worktreeIsolated, // black-bot H-2: explicit signal for output renderer
         });
       }
     }
@@ -132,6 +278,7 @@ export function detectClaimOverlaps(rootDir = process.cwd(), { taskId, includeAl
 export function detectOutOfScopeEdits(claimId, editedFiles, rootDir = process.cwd()) {
   const claim = loadClaim(claimId, rootDir);
   if (!claim) return { ok: false, reason: 'claim-not-found' };
+  // pathMatchesScope handles normalizeSep on both path AND each pattern internally
   const outside = editedFiles.filter((f) => !pathMatchesScope(f, claim.write_scope));
   return { ok: true, outside, total_edits: editedFiles.length };
 }

package/src/lib/agent-events.mjs

@@ -3,15 +3,74 @@ import { join, dirname } from 'node:path';
 
 const TASKS_DIR = '.dw/tasks';
 const MAX_EVENT_BYTES = 4096;
+const CLAIM_ID_CLIP = 64;
 
 export function eventsFile(taskId, rootDir = process.cwd()) {
   return join(rootDir, TASKS_DIR, taskId, 'events.jsonl');
 }
 
+// Issue #14 Bug 1 fix — Smart 3-step truncation preserves identifying fields.
+// Previous behavior dropped EVERYTHING except ts + event (claim_id lost → audit useless).
+// Step 1: truncate write_scope/read_scope arrays (the usual oversized field) when non-empty
+// Step 2: hard-cap to IDENTIFY_FIELDS (ts, event, claim_id, agent_id, vendor, role, subtasks)
+// Step 3: backstop for adversarial inputs — clip claim_id to 64 chars + subtasks to count summary
+// (black-bot C-1)
+const IDENTIFY_FIELDS = ['ts', 'event', 'claim_id', 'agent_id', 'vendor', 'role', 'subtasks'];
+
+function smartTruncate(enriched, originalBytes) {
+  // Step 1: scope-only truncation when arrays are non-empty (black-bot M-10)
+  const candidate = { ...enriched };
+  const truncatedFields = [];
+  if (Array.isArray(candidate.write_scope) && candidate.write_scope.length > 0) {
+    truncatedFields.push('write_scope');
+    candidate.write_scope = [`(${candidate.write_scope.length} paths — truncated for size)`];
+  }
+  if (Array.isArray(candidate.read_scope) && candidate.read_scope.length > 0) {
+    truncatedFields.push('read_scope');
+    candidate.read_scope = [`(${candidate.read_scope.length} paths — truncated for size)`];
+  }
+  if (truncatedFields.length > 0) {
+    candidate._dw_meta = { truncated: true, truncated_fields: truncatedFields, original_size_bytes: originalBytes };
+    const afterScope = JSON.stringify(candidate) + '\n';
+    if (Buffer.byteLength(afterScope, 'utf8') <= MAX_EVENT_BYTES) return afterScope;
+  }
+
+  // Step 2: hard-cap to identifying fields
+  const minimal = {};
+  for (const f of IDENTIFY_FIELDS) {
+    if (enriched[f] !== undefined) minimal[f] = enriched[f];
+  }
+  minimal._dw_meta = { truncated: true, original_size_bytes: originalBytes };
+  let line = JSON.stringify(minimal) + '\n';
+  if (Buffer.byteLength(line, 'utf8') <= MAX_EVENT_BYTES) return line;
+
+  // Step 3: backstop for adversarial inputs (long claim_id from many concatenated subtask slugs;
+  // huge subtasks array). Clip + summarize. (black-bot C-1)
+  if (typeof minimal.claim_id === 'string' && minimal.claim_id.length > CLAIM_ID_CLIP) {
+    minimal.claim_id = minimal.claim_id.slice(0, CLAIM_ID_CLIP) + '…(clipped)';
+  }
+  if (Array.isArray(minimal.subtasks) && minimal.subtasks.length > 3) {
+    minimal.subtasks = [`(${minimal.subtasks.length} subtasks — truncated)`];
+  }
+  minimal._dw_meta = { truncated: true, original_size_bytes: originalBytes, hard_clipped: true };
+  return JSON.stringify(minimal) + '\n';
+}
+
+/**
+ * Append an event to .dw/tasks/{taskId}/events.jsonl.
+ *
+ * @returns {{ok: boolean, error?: Error}}
+ *   `ok: false` means the write failed (file locked / permission / disk).
+ *   All callers SHOULD check the return value and surface a warning if !ok.
+ *   Previous boolean-only return was silently ignored at 3 CLI callers (issue #14 Bug 3).
+ */
 export function logAgentEvent(taskId, event, rootDir = process.cwd()) {
   const file = eventsFile(taskId, rootDir);
   const dir = dirname(file);
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  if (!existsSync(dir)) {
+    try { mkdirSync(dir, { recursive: true }); }
+    catch (e) { return { ok: false, error: e }; }
+  }
 
   const enriched = {
     ts: new Date().toISOString().replace(/\.\d+Z$/, 'Z'),
@@ -20,24 +79,54 @@ export function logAgentEvent(taskId, event, rootDir = process.cwd()) {
   let line = JSON.stringify(enriched) + '\n';
   const originalBytes = Buffer.byteLength(line, 'utf8');
   if (originalBytes > MAX_EVENT_BYTES) {
-    const trimmed = { ts: enriched.ts, event: enriched.event || 'unknown', _truncated: true, _original_size_bytes: originalBytes };
-    line = JSON.stringify(trimmed) + '\n';
+    line = smartTruncate(enriched, originalBytes);
   }
   try {
     appendFileSync(file, line, 'utf8');
-    return true;
-  } catch {
-    return false;
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: e };
   }
 }
 
-export function readEvents(taskId, rootDir = process.cwd()) {
+// Track files for which we've already warned about silently-skipped lines (black-bot C-2:
+// emit ONE warning per file per process, don't spam stderr on every read).
+const _skipWarnedFiles = new Set();
+
+/**
+ * Read events.jsonl for a task.
+ *
+ * @param {string} taskId
+ * @param {string} rootDir
+ * @param {object} opts
+ * @param {boolean} opts.strict  When true, malformed lines are returned inline as
+ *                               `{_malformed: true, _line, _raw, _error}` (for `dw agent verify`).
+ *                               When false (default), malformed lines are skipped, but a
+ *                               stderr warning fires once per file per process (black-bot C-2:
+ *                               silent-skip-by-default = the original bug).
+ * @returns {object[]} Parsed events (plus `_malformed` markers if strict).
+ */
+export function readEvents(taskId, rootDir = process.cwd(), { strict = false } = {}) {
   const file = eventsFile(taskId, rootDir);
   if (!existsSync(file)) return [];
   const lines = readFileSync(file, 'utf8').split('\n').filter(Boolean);
   const out = [];
-  for (const line of lines) {
-    try { out.push(JSON.parse(line)); } catch { /* skip malformed */ }
+  let skipped = 0;
+  for (let i = 0; i < lines.length; i++) {
+    try { out.push(JSON.parse(lines[i])); }
+    catch (err) {
+      if (strict) {
+        out.push({ _malformed: true, _line: i + 1, _raw: lines[i], _error: err.message });
+      } else {
+        skipped++;
+      }
+    }
+  }
+  if (!strict && skipped > 0 && !_skipWarnedFiles.has(file)) {
+    _skipWarnedFiles.add(file);
+    try {
+      process.stderr.write(`⚠  events.jsonl: ${skipped} malformed line(s) skipped in ${file}. Run \`dw agent verify ${taskId}\` to inspect.\n`);
+    } catch { /* stderr may be closed in piped contexts */ }
   }
   return out;
 }

package/src/lib/goal-events.mjs

@@ -1,8 +1,9 @@
-import { appendFileSync, existsSync, readFileSync, mkdirSync, statSync, renameSync } from 'node:fs';
+import { appendFileSync, existsSync, readFileSync, mkdirSync, statSync, renameSync, unlinkSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 
 const EVENTS_FILE_RELATIVE = '.dw/events-global.jsonl';
 const MAX_EVENT_BYTES = 4096;
+const CLAIM_ID_CLIP = 64;
 const ROTATE_BYTES = 500 * 1024;     // C-4: 500KB
 const ROTATE_LINES = 5000;            // C-4: 5000 lines
 
@@ -32,19 +33,70 @@ function rotateIfNeeded(file) {
   if (existsSync(archive)) {
     const existing = readFileSync(file, 'utf8');
     appendFileSync(archive, existing, 'utf8');
-    try {
-      const { unlinkSync } = require('node:fs');
-      unlinkSync(file);
-    } catch { /* best-effort */ }
+    // Issue #14 black-bot C-3 fix: was `const { unlinkSync } = require('node:fs')` in ESM
+    // which throws ReferenceError. Use the import at top of file instead.
+    try { unlinkSync(file); } catch { /* best-effort */ }
   } else {
     renameSync(file, archive);
   }
 }
 
+// Issue #14 Bug 1 — same smart truncation as agent-events.mjs adapted for goal events.
+// Identifying fields differ: goal_id + field instead of claim_id + agent_id.
+const GOAL_IDENTIFY_FIELDS = ['ts', 'event', 'goal_id', 'kr_id', 'field', 'changed_by'];
+
+function smartTruncateGoal(enriched, originalBytes) {
+  // Step 1: truncate large string-valued fields like `new` (long summaries) or `staged_files` arrays
+  const candidate = { ...enriched };
+  const truncatedFields = [];
+  for (const key of ['old', 'new', 'summary']) {
+    if (typeof candidate[key] === 'string' && candidate[key].length > 500) {
+      truncatedFields.push(key);
+      candidate[key] = candidate[key].slice(0, 500) + '…(truncated)';
+    }
+  }
+  for (const key of ['linked_task_ids', 'staged_files', 'out_of_scope']) {
+    if (Array.isArray(candidate[key]) && candidate[key].length > 0) {
+      truncatedFields.push(key);
+      const count = candidate[key].length;
+      candidate[key] = [`(${count} items — truncated for size)`];
+    }
+  }
+  if (truncatedFields.length > 0) {
+    candidate._dw_meta = { truncated: true, truncated_fields: truncatedFields, original_size_bytes: originalBytes };
+    const afterScope = JSON.stringify(candidate) + '\n';
+    if (Buffer.byteLength(afterScope, 'utf8') <= MAX_EVENT_BYTES) return afterScope;
+  }
+
+  // Step 2: hard-cap to identifying fields
+  const minimal = {};
+  for (const f of GOAL_IDENTIFY_FIELDS) {
+    if (enriched[f] !== undefined) minimal[f] = enriched[f];
+  }
+  minimal._dw_meta = { truncated: true, original_size_bytes: originalBytes };
+  let line = JSON.stringify(minimal) + '\n';
+  if (Buffer.byteLength(line, 'utf8') <= MAX_EVENT_BYTES) return line;
+
+  // Step 3: backstop — clip goal_id if pathologically long
+  if (typeof minimal.goal_id === 'string' && minimal.goal_id.length > CLAIM_ID_CLIP) {
+    minimal.goal_id = minimal.goal_id.slice(0, CLAIM_ID_CLIP) + '…(clipped)';
+  }
+  minimal._dw_meta = { truncated: true, original_size_bytes: originalBytes, hard_clipped: true };
+  return JSON.stringify(minimal) + '\n';
+}
+
+/**
+ * Append a goal event to .dw/events-global.jsonl.
+ *
+ * @returns {{ok: boolean, error?: Error}} (issue #14 Bug 3 fix — was bare boolean)
+ */
 export function logGoalEvent(event, rootDir = process.cwd()) {
   const file = eventsGlobalFile(rootDir);
   const dir = dirname(file);
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  if (!existsSync(dir)) {
+    try { mkdirSync(dir, { recursive: true }); }
+    catch (e) { return { ok: false, error: e }; }
+  }
 
   rotateIfNeeded(file);
 
@@ -55,25 +107,41 @@ export function logGoalEvent(event, rootDir = process.cwd()) {
   let line = JSON.stringify(enriched) + '\n';
   const originalBytes = Buffer.byteLength(line, 'utf8');
   if (originalBytes > MAX_EVENT_BYTES) {
-    const trimmed = { ts: enriched.ts, event: enriched.event || 'unknown', _truncated: true, _original_size_bytes: originalBytes };
-    line = JSON.stringify(trimmed) + '\n';
+    line = smartTruncateGoal(enriched, originalBytes);
   }
   try {
     appendFileSync(file, line, 'utf8');
-    return true;
-  } catch {
-    return false;
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: e };
   }
 }
 
-export function readGoalEvents(rootDir = process.cwd(), { limit = 100, offset = 0 } = {}) {
+// Track files for which we've already warned about silently-skipped lines (black-bot C-2).
+const _skipWarnedGoalFiles = new Set();
+
+export function readGoalEvents(rootDir = process.cwd(), { limit = 100, offset = 0, strict = false } = {}) {
   const file = eventsGlobalFile(rootDir);
   if (!existsSync(file)) return [];
   const lines = readFileSync(file, 'utf8').split('\n').filter(Boolean);
   const sliced = lines.slice(Math.max(0, lines.length - offset - limit), lines.length - offset);
   const out = [];
-  for (const line of sliced) {
-    try { out.push(JSON.parse(line)); } catch { /* skip malformed */ }
+  let skipped = 0;
+  for (let i = 0; i < sliced.length; i++) {
+    try { out.push(JSON.parse(sliced[i])); }
+    catch (err) {
+      if (strict) {
+        out.push({ _malformed: true, _line: i + 1, _raw: sliced[i], _error: err.message });
+      } else {
+        skipped++;
+      }
+    }
+  }
+  if (!strict && skipped > 0 && !_skipWarnedGoalFiles.has(file)) {
+    _skipWarnedGoalFiles.add(file);
+    try {
+      process.stderr.write(`⚠  events-global.jsonl: ${skipped} malformed line(s) skipped in ${file}.\n`);
+    } catch { /* stderr may be closed */ }
   }
   return out;
 }