create-harness-vibe-coding 0.8.13 → 0.8.17

package/templates/common/Harness/{architecture.md → project/architecture.md}

@@ -67,7 +67,7 @@ State in this repo should be explicit, serializable, and owned by one layer.
 
 - **Location**: `src/prompts.js`
 - **Responsibility**: Ask basic interactive npx questions: project name and target directory.
-- **Does NOT handle**: Agent-link install intake. That matrix is read by coding agents from `README.md` and `Harness/SETUP.md`.
+- **Does NOT handle**: Agent-link install intake. That matrix is read by coding agents from `README.md` and `Harness/specs/guides/SETUP.md`.
 
 ### 4.3 Generator Core
 

package/templates/common/Harness/research/README.md

@@ -21,7 +21,7 @@ Built-in agents:
 - `.claude/agents/researcher.md`: product, market, open-source, dependency, pricing, policy, and ecosystem research.
 - `.claude/agents/docs-researcher.md`: official docs, API, SDK, config, limits, errors, and examples verification.
 
-For multi-agent research plus build work, create the dispatch table in `Harness/tasks/<task-id>/PLAN.md` and follow `Harness/dispatch.md`.
+For multi-agent research plus build work, create the dispatch table in `Harness/tasks/<task-id>/PLAN.md` and follow `Harness/specs/runtime/dispatch.md`.
 
 Research Agent input:
 
@@ -107,11 +107,11 @@ Use these patterns when turning research into PRD or feature docs:
 - Research process, queries, and limitations: this file or `Harness/tasks/<task-id>/PLAN.md`.
 - Final research decisions: [research-results.md](research-results.md).
 - Product scope: [PRD.md](PRD.md).
-- Architecture consequences: `Harness/architecture.md`.
+- Architecture consequences: `Harness/project/architecture.md`.
 
 ## Architecture Decision References
 
-When filling `Harness/architecture.md` and `Harness/research/research-results.md`, use these high-trust sources as starting points. Search within them; do not read them whole.
+When filling `Harness/project/architecture.md` and `Harness/research/research-results.md`, use these high-trust sources as starting points. Search within them; do not read them whole.
 
 ### System Design & Architecture Patterns
 

package/templates/common/Harness/scripts/archive-tasks.mjs

@@ -1,26 +1,21 @@
 #!/usr/bin/env node
-import fs from 'node:fs';
+import { spawnSync } from 'node:child_process';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 
-const root = process.cwd();
-const tasksDir = path.join(root, 'Harness', 'tasks');
-const archiveDir = path.join(tasksDir, '_archive');
-
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const taskState = path.join(__dirname, 'task-state.mjs');
 const args = process.argv.slice(2);
-const flags = {
-  dryRun: !args.includes('--apply'),
-  apply: args.includes('--apply'),
-  json: args.includes('--json'),
-  keep: parseInt(args.includes('--keep') ? args[args.indexOf('--keep') + 1] : '5', 10),
-  task: args.includes('--task') ? args[args.indexOf('--task') + 1] : null,
-};
 
 if (args.includes('--help') || args.includes('-h')) {
   console.log(`Usage: node Harness/scripts/archive-tasks.mjs [options]
 
+Compatibility entry for: node Harness/scripts/task-state.mjs archive [options]
+
 Options:
   --dry-run        Show what would be archived without moving files (default)
-  --apply          Execute the archive moves
+  --apply          Execute archive moves
   --keep <n>       Keep at most <n> non-archived tasks (default: 5)
   --task <id>      Archive only the specified task
   --json           Output results as JSON
@@ -28,212 +23,9 @@ Options:
   process.exit(0);
 }
 
-const RESERVED = new Set(['_template', '_archive', 'auto']);
-const NEVER_ARCHIVE_STATUSES = new Set([
-  'active', 'blocked', 'in_progress', 'running', 'pending', 'needs-user-decision',
-]);
-const SAFE_ARCHIVE_STATUSES = new Set([
-  'complete', 'verified', 'archived', 'abandoned', 'obsolete', 'done', 'closed', 'closeout',
-]);
-
-function readStateJson(taskDir) {
-  const statePath = path.join(tasksDir, taskDir, 'STATE.json');
-  if (!fs.existsSync(statePath)) return null;
-  try {
-    return JSON.parse(fs.readFileSync(statePath, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-function readProgressPhase(taskDir) {
-  const progressPath = path.join(tasksDir, taskDir, 'PROGRESS.md');
-  if (!fs.existsSync(progressPath)) return null;
-  const text = fs.readFileSync(progressPath, 'utf8');
-  // Match "- Phase: X", "Phase: X", or "Current: X" (task capsules use all three).
-  const match = text.match(/^(?:-\s*)?(?:Phase|Current(?: phase)?):\s*([A-Za-z_-]+)/mi);
-  return match ? match[1].trim().toLowerCase() : null;
-}
-
-function canArchive(taskDir) {
-  if (RESERVED.has(taskDir)) return { ok: false, reason: 'reserved directory' };
-  if (taskDir.startsWith('_')) return { ok: false, reason: 'system directory' };
-
-  const state = readStateJson(taskDir);
-  const status = state?.status?.toLowerCase() || '';
-  const phase = state?.phase?.toLowerCase() || '';
-
-  if (NEVER_ARCHIVE_STATUSES.has(status)) {
-    return { ok: false, reason: `status "${status}" is never auto-archived` };
-  }
-  if (NEVER_ARCHIVE_STATUSES.has(phase)) {
-    return { ok: false, reason: `phase "${phase}" is never auto-archived` };
-  }
-
-  if (SAFE_ARCHIVE_STATUSES.has(status) || SAFE_ARCHIVE_STATUSES.has(phase)) {
-    return { ok: true, reason: `status/phase allows archive` };
-  }
-
-  // Fallback: check PROGRESS.md phase
-  const progressPhase = readProgressPhase(taskDir);
-  if (progressPhase && SAFE_ARCHIVE_STATUSES.has(progressPhase)) {
-    return { ok: true, reason: `PROGRESS.md phase "${progressPhase}" allows archive` };
-  }
-  if (progressPhase && NEVER_ARCHIVE_STATUSES.has(progressPhase)) {
-    return { ok: false, reason: `PROGRESS.md phase "${progressPhase}" is never auto-archived` };
-  }
-
-  return { ok: false, reason: 'status indeterminate — requires manual review' };
-}
-
-function scandir(dir) {
-  if (!fs.existsSync(dir)) return [];
-  return fs.readdirSync(dir, { withFileTypes: true })
-    .filter(e => e.isDirectory())
-    .map(e => e.name);
-}
-
-function safeResolve(...segments) {
-  const resolved = path.resolve(root, ...segments);
-  const normalized = resolved.replace(/\\/g, '/');
-  const tasksPrefix = tasksDir.replace(/\\/g, '/');
-  if (!normalized.startsWith(tasksPrefix + '/') && normalized !== tasksPrefix) {
-    throw new Error(`Path "${resolved}" is outside Harness/tasks/ — aborting`);
-  }
-  return resolved;
-}
-
-function mkdirIfMissing(dir) {
-  if (!fs.existsSync(dir)) {
-    if (flags.apply) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    return true;
-  }
-  return false;
-}
-
-function resultsToJson(results) {
-  return JSON.stringify(results, null, 2);
-}
-
-// Main
-const taskDirs = scandir(tasksDir).filter(d => !RESERVED.has(d));
-const candidates = flags.task
-  ? taskDirs.filter(d => d === flags.task)
-  : taskDirs;
-
-if (flags.task && candidates.length === 0) {
-  const msg = `Task "${flags.task}" not found in Harness/tasks/`;
-  if (flags.json) console.log(resultsToJson({ error: msg }));
-  else console.error(msg);
-  process.exit(1);
-}
-
-const results = [];
-const skipped = [];
-
-// Read active task from PROGRESS.md
-const progressPath = path.join(root, 'Harness', 'PROGRESS.md');
-let activeTask = null;
-if (fs.existsSync(progressPath)) {
-  const text = fs.readFileSync(progressPath, 'utf8');
-  const match = text.match(/## Active Task\s*\n+\s*-\s*(.+)/);
-  if (match) activeTask = match[1].trim();
-}
-
-const archiveable = [];
-for (const dir of candidates) {
-  if (dir === activeTask) {
-    skipped.push({ dir, reason: 'active task' });
-    continue;
-  }
-  const result = canArchive(dir);
-  if (result.ok) {
-    archiveable.push(dir);
-  } else {
-    skipped.push({ dir, reason: result.reason });
-  }
-}
-
-// Sort by modified time (oldest first) to archive oldest first
-archiveable.sort((a, b) => {
-  const statA = fs.statSync(path.join(tasksDir, a));
-  const statB = fs.statSync(path.join(tasksDir, b));
-  return statA.mtimeMs - statB.mtimeMs;
+const result = spawnSync(process.execPath, [taskState, 'archive', ...args], {
+  cwd: process.cwd(),
+  stdio: 'inherit',
 });
 
-// Determine how many to archive: keep `flags.keep` non-archived
-const currentNonArchived = taskDirs.length;
-const toArchiveCount = flags.task
-  ? archiveable.length
-  : Math.max(0, currentNonArchived - flags.keep);
-
-const toArchive = archiveable.slice(0, toArchiveCount);
-
-for (const dir of toArchive) {
-  const stat = fs.statSync(path.join(tasksDir, dir));
-  const year = new Date(stat.mtimeMs).getFullYear().toString();
-  const src = safeResolve('Harness', 'tasks', dir);
-  const destDir = safeResolve('Harness', 'tasks', '_archive', year);
-  const dest = path.join(destDir, dir);
-
-  if (flags.apply) {
-    mkdirIfMissing(destDir);
-    fs.renameSync(src, dest);
-
-    // Update STATE.json status to archived
-    const statePath = path.join(dest, 'STATE.json');
-    if (fs.existsSync(statePath)) {
-      try {
-        const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
-        state.status = 'archived';
-        state.phase = 'archived';
-        state.updatedAt = new Date().toISOString();
-        fs.writeFileSync(statePath, JSON.stringify(state, null, 2) + '\n');
-      } catch {
-        // If STATE.json is broken, leave it alone
-      }
-    }
-
-    results.push({ dir, year, action: 'archived', status: 'moved' });
-  } else {
-    results.push({ dir, year, action: 'would-archive', status: 'dry-run' });
-  }
-}
-
-for (const s of skipped) {
-  results.push({ dir: s.dir, year: null, action: 'skipped', status: s.reason });
-}
-
-// Update INDEX.md
-const indexPath = path.join(archiveDir, 'INDEX.md');
-const indexEntries = results
-  .filter(r => r.action === 'archived')
-  .map(r => `| ${r.dir} | ${r.year} | ${new Date().toISOString().split('T')[0]} |`);
-
-if (indexEntries.length > 0 && flags.apply) {
-  mkdirIfMissing(archiveDir);
-  const existingIndex = fs.existsSync(indexPath)
-    ? fs.readFileSync(indexPath, 'utf8')
-    : '| Task | Year | Archived |\n|------|------|----------|\n';
-  const newEntries = indexEntries.join('\n') + '\n';
-  fs.writeFileSync(indexPath, existingIndex + newEntries);
-}
-
-if (flags.json) {
-  console.log(resultsToJson({
-    scanned: candidates.length,
-    archiveable: archiveable.length,
-    toArchive: toArchive.length,
-    skipped: skipped.length,
-    dryRun: flags.dryRun,
-    results,
-  }));
-} else {
-  if (flags.dryRun) console.log('[DRY RUN] No files moved. Use --apply to execute.');
-  console.log(`Scanned: ${candidates.length}, Archiveable: ${archiveable.length}, To archive: ${toArchive.length}, Skipped: ${skipped.length}`);
-  for (const r of results) {
-    console.log(`  ${r.action}: ${r.dir} (${r.status})${r.year ? ' → _archive/' + r.year : ''}`);
-  }
-}
+process.exit(result.status ?? 1);

package/templates/common/Harness/scripts/context-budget.mjs

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+
+const args = new Set(process.argv.slice(2));
+const rootArgIndex = process.argv.indexOf('--root');
+const root = rootArgIndex !== -1 && process.argv[rootArgIndex + 1]
+  ? path.resolve(process.argv[rootArgIndex + 1])
+  : process.cwd();
+const json = args.has('--json');
+
+const routes = [
+  {
+    id: 'thin-startup',
+    maxBytes: 12500,
+    paths: [
+      'CLAUDE.md',
+      'Harness/memory/startup-hints.md',
+    ],
+  },
+  {
+    id: 'wf-router-prefix',
+    maxBytes: 42000,
+    paths: [
+      'CLAUDE.md',
+      'Harness/MEMORY.md',
+      'Harness/README.md',
+    ],
+  },
+  {
+    id: 'wf-light-prefix',
+    maxBytes: 58000,
+    paths: [
+      'CLAUDE.md',
+      'Harness/MEMORY.md',
+      'Harness/README.md',
+      'Harness/specs/workflows/WF.md',
+      'Harness/specs/workflows/WF-KERNEL.md',
+    ],
+  },
+  {
+    id: 'cache-diagnostics-route',
+    maxBytes: 36000,
+    paths: [
+      'Harness/specs/runtime/context-loading.md',
+      'Harness/specs/workflows/WF-KERNEL.md',
+      'Harness/specs/runtime/dispatch.md',
+      '.claude/skills/wf-agents-docs/SKILL.md',
+    ],
+  },
+];
+
+function readBytes(rel) {
+  const abs = path.join(root, ...rel.split('/'));
+  if (!fs.existsSync(abs)) return { missing: true, bytes: 0 };
+  return { missing: false, bytes: Buffer.byteLength(fs.readFileSync(abs)) };
+}
+
+function routeResult(route) {
+  const files = route.paths.map(rel => ({ path: rel, ...readBytes(rel) }));
+  const totalBytes = files.reduce((sum, file) => sum + file.bytes, 0);
+  const missing = files.filter(file => file.missing).map(file => file.path);
+  return {
+    id: route.id,
+    maxBytes: route.maxBytes,
+    totalBytes,
+    approxTokens: Math.ceil(totalBytes / 4),
+    status: missing.length > 0 || totalBytes > route.maxBytes ? 'FAIL' : 'PASS',
+    missing,
+    files,
+  };
+}
+
+const results = routes.map(routeResult);
+const ok = results.every(result => result.status === 'PASS');
+
+if (json) {
+  console.log(JSON.stringify({
+    ok,
+    root,
+    note: 'Budgets are route-profile regression guards, not runtime exclusion rules. approxTokens is bytes/4, not provider token accounting.',
+    results,
+  }, null, 2));
+} else {
+  console.log('Context budgets are route-profile regression guards, not runtime exclusion rules.');
+  for (const result of results) {
+    console.log(`${result.status} ${result.id}: ${result.totalBytes}/${result.maxBytes} bytes (~${result.approxTokens} tokens)`);
+    for (const file of result.files) {
+      const state = file.missing ? 'MISSING' : `${file.bytes} bytes`;
+      console.log(`  - ${file.path}: ${state}`);
+    }
+  }
+}
+
+process.exit(ok ? 0 : 1);