@harness-engineering/cli 1.12.0 → 1.13.1

package/dist/{chunk-AE2OWWDH.js → chunk-PQ5YK4AY.js}

@@ -3,27 +3,23 @@ import {
   Ok
 } from "./chunk-MHBMTPW7.js";
 
-// ../core/dist/chunk-ZHGBWFYD.mjs
+// ../core/dist/chunk-D6VFA6AS.mjs
 import { z } from "zod";
-import { relative as relative2 } from "path";
 import { createHash } from "crypto";
 import { minimatch } from "minimatch";
 import { access, constants, readFile } from "fs";
 import { promisify } from "util";
+import { relative } from "path";
 import { glob } from "glob";
-import { dirname, resolve, relative } from "path";
-import { relative as relative3 } from "path";
+import { dirname, resolve } from "path";
 import { readFileSync, writeFileSync, renameSync, mkdirSync, existsSync } from "fs";
 import { randomBytes } from "crypto";
 import { join, dirname as dirname2 } from "path";
-import { relative as relative4 } from "path";
 import { readFile as readFile2 } from "fs/promises";
-import { relative as relative5 } from "path";
-import { relative as relative6 } from "path";
 import { readFile as readFile3, readdir } from "fs/promises";
-import { join as join2, relative as relative7 } from "path";
+import { join as join2 } from "path";
 import { readFile as readFile4, readdir as readdir2 } from "fs/promises";
-import { join as join3, relative as relative8, dirname as dirname3, resolve as resolve2 } from "path";
+import { join as join3, dirname as dirname3, resolve as resolve2 } from "path";
 var ArchMetricCategorySchema = z.enum([
   "circular-deps",
   "layer-violations",
@@ -106,8 +102,7 @@ var ConstraintRuleSchema = z.object({
   // forward-compat for governs edges
 });
 function violationId(relativePath, category, normalizedDetail) {
-  const path13 = relativePath.replace(/\\/g, "/");
-  const input = `${path13}:${category}:${normalizedDetail}`;
+  const input = `${relativePath}:${category}:${normalizedDetail}`;
   return createHash("sha256").update(input).digest("hex");
 }
 function constraintRuleId(category, scope, description) {
@@ -139,17 +134,17 @@ function resolveFileToLayer(file, layers) {
 }
 var accessAsync = promisify(access);
 var readFileAsync = promisify(readFile);
-async function fileExists(path13) {
+async function fileExists(path20) {
   try {
-    await accessAsync(path13, constants.F_OK);
+    await accessAsync(path20, constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
-async function readFileContent(path13) {
+async function readFileContent(path20) {
   try {
-    const content = await readFileAsync(path13, "utf-8");
+    const content = await readFileAsync(path20, "utf-8");
     return Ok(content);
   } catch (error) {
     return Err(error);
@@ -158,6 +153,9 @@ async function readFileContent(path13) {
 async function findFiles(pattern, cwd = process.cwd()) {
   return glob(pattern, { cwd, absolute: true });
 }
+function relativePosix(from, to) {
+  return relative(from, to).replaceAll("\\", "/");
+}
 function resolveImportPath(importSource, fromFile, _rootDir) {
   if (!importSource.startsWith(".") && !importSource.startsWith("/")) {
     return null;
@@ -209,8 +207,8 @@ async function buildDependencyGraph(files, parser, graphDependencyData) {
 function checkLayerViolations(graph, layers, rootDir) {
   const violations = [];
   for (const edge of graph.edges) {
-    const fromRelative = relative(rootDir, edge.from);
-    const toRelative = relative(rootDir, edge.to);
+    const fromRelative = relativePosix(rootDir, edge.from);
+    const toRelative = relativePosix(rootDir, edge.to);
     const fromLayer = resolveFileToLayer(fromRelative, layers);
     const toLayer = resolveFileToLayer(toRelative, layers);
     if (!fromLayer || !toLayer) continue;
@@ -436,8 +434,8 @@ var CircularDepsCollector = class {
     }
     const { cycles, largestCycle } = result.value;
     const violations = cycles.map((cycle) => {
-      const cyclePath = cycle.cycle.map((f) => relative2(rootDir, f)).join(" -> ");
-      const firstFile = relative2(rootDir, cycle.cycle[0]);
+      const cyclePath = cycle.cycle.map((f) => relativePosix(rootDir, f)).join(" -> ");
+      const firstFile = relativePosix(rootDir, cycle.cycle[0]);
       return {
         id: violationId(firstFile, this.category, cyclePath),
         file: firstFile,
@@ -499,8 +497,8 @@ var LayerViolationCollector = class {
       (v) => v.reason === "WRONG_LAYER"
     );
     const violations = layerViolations.map((v) => {
-      const relFile = relative3(rootDir, v.file);
-      const relImport = relative3(rootDir, v.imports);
+      const relFile = relativePosix(rootDir, v.file);
+      const relImport = relativePosix(rootDir, v.imports);
       const detail = `${v.fromLayer} -> ${v.toLayer}: ${relFile} imports ${relImport}`;
       return {
         id: violationId(relFile, this.category, detail),
@@ -980,7 +978,7 @@ var ComplexityCollector = class {
       (v) => v.severity === "error" || v.severity === "warning"
     );
     const violations = filtered.map((v) => {
-      const relFile = relative4(rootDir, v.file);
+      const relFile = relativePosix(rootDir, v.file);
       const idDetail = `${v.metric}:${v.function}`;
       return {
         id: violationId(relFile, this.category, idDetail),
@@ -1202,7 +1200,7 @@ var CouplingCollector = class {
       (v) => v.severity === "error" || v.severity === "warning"
     );
     const violations = filtered.map((v) => {
-      const relFile = relative5(rootDir, v.file);
+      const relFile = relativePosix(rootDir, v.file);
       const idDetail = `${v.metric}`;
       return {
         id: violationId(relFile, this.category, idDetail),
@@ -1266,8 +1264,8 @@ var ForbiddenImportCollector = class {
       (v) => v.reason === "FORBIDDEN_IMPORT"
     );
     const violations = forbidden.map((v) => {
-      const relFile = relative6(rootDir, v.file);
-      const relImport = relative6(rootDir, v.imports);
+      const relFile = relativePosix(rootDir, v.file);
+      const relImport = relativePosix(rootDir, v.imports);
       const detail = `forbidden import: ${relFile} -> ${relImport}`;
       return {
         id: violationId(relFile, this.category, detail),
@@ -1319,10 +1317,10 @@ async function discoverModules(rootDir) {
         }
       }
       modules.push({
-        modulePath: relative7(rootDir, dir),
+        modulePath: relativePosix(rootDir, dir),
         fileCount: tsFiles.length,
         totalLoc,
-        files: tsFiles.map((f) => relative7(rootDir, f))
+        files: tsFiles.map((f) => relativePosix(rootDir, f))
       });
     }
     for (const sub of subdirs) {
@@ -1494,7 +1492,7 @@ var DepDepthCollector = class {
     }
     const moduleMap = /* @__PURE__ */ new Map();
     for (const file of allFiles) {
-      const relDir = relative8(rootDir, dirname3(file));
+      const relDir = relativePosix(rootDir, dirname3(file));
       if (!moduleMap.has(relDir)) moduleMap.set(relDir, []);
       moduleMap.get(relDir).push(file);
     }
@@ -1743,19 +1741,18 @@ var archMatchers = {
 // ../core/dist/index.mjs
 import { join as join4, dirname as dirname4 } from "path";
 import { minimatch as minimatch2 } from "minimatch";
-import { basename, relative as relative9 } from "path";
-import { join as join22, basename as basename2, relative as relative22 } from "path";
-import { relative as relative32, basename as basename3, dirname as dirname22 } from "path";
+import { basename } from "path";
+import { join as join22, basename as basename2 } from "path";
+import { basename as basename3, dirname as dirname22 } from "path";
 import { z as z2 } from "zod";
 import * as fs from "fs/promises";
 import * as fs2 from "fs/promises";
 import { parse } from "@typescript-eslint/typescript-estree";
-import { join as join32, resolve as resolve3, relative as relative42 } from "path";
+import { join as join32, resolve as resolve3 } from "path";
 import { minimatch as minimatch22 } from "minimatch";
 import { dirname as dirname32, resolve as resolve22 } from "path";
 import { dirname as dirname42, resolve as resolve32 } from "path";
 import { minimatch as minimatch3 } from "minimatch";
-import { relative as relative52 } from "path";
 import { readdirSync, statSync } from "fs";
 import { join as join42 } from "path";
 import * as fs3 from "fs";
@@ -1770,31 +1767,45 @@ import * as path from "path";
 import { appendFileSync, writeFileSync as writeFileSync22, existsSync as existsSync22, mkdirSync as mkdirSync22 } from "fs";
 import { dirname as dirname7 } from "path";
 import { z as z3 } from "zod";
-import * as fs6 from "fs";
-import * as path3 from "path";
-import { execSync as execSync2 } from "child_process";
+import * as fs8 from "fs";
+import * as path5 from "path";
+import * as fs7 from "fs";
+import * as path4 from "path";
 import * as fs5 from "fs";
 import * as path2 from "path";
 import { execSync } from "child_process";
 import { z as z4 } from "zod";
-import * as fs8 from "fs/promises";
-import { z as z5 } from "zod";
-import * as fs7 from "fs";
-import * as path4 from "path";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path3 from "path";
+import * as fs9 from "fs";
 import * as path6 from "path";
+import * as fs10 from "fs";
 import * as path7 from "path";
+import * as fs11 from "fs";
 import * as path8 from "path";
-import * as fs9 from "fs";
+import * as fs12 from "fs";
 import * as path9 from "path";
-import { z as z6 } from "zod";
-import * as fs10 from "fs/promises";
+import { execSync as execSync2 } from "child_process";
+import * as fs13 from "fs";
 import * as path10 from "path";
-import * as fs11 from "fs/promises";
+import * as fs15 from "fs/promises";
+import { z as z5 } from "zod";
+import * as fs14 from "fs";
 import * as path11 from "path";
-import * as ejs from "ejs";
-import * as fs12 from "fs";
 import * as path12 from "path";
+import * as path13 from "path";
+import * as path14 from "path";
+import * as path15 from "path";
+import * as fs16 from "fs";
+import * as path16 from "path";
+import { z as z6 } from "zod";
+import * as fs17 from "fs/promises";
+import * as path17 from "path";
+import * as fs18 from "fs/promises";
+import * as path18 from "path";
+import * as ejs from "ejs";
+import * as fs19 from "fs";
+import * as path19 from "path";
 import * as os from "os";
 import { spawn } from "child_process";
 async function validateFileStructure(projectPath, conventions) {
@@ -1832,15 +1843,15 @@ function validateConfig(data, schema) {
   let message = "Configuration validation failed";
   const suggestions = [];
   if (firstError) {
-    const path13 = firstError.path.join(".");
-    const pathDisplay = path13 ? ` at "${path13}"` : "";
+    const path20 = firstError.path.join(".");
+    const pathDisplay = path20 ? ` at "${path20}"` : "";
     if (firstError.code === "invalid_type") {
       const received = firstError.received;
       const expected = firstError.expected;
       if (received === "undefined") {
         code = "MISSING_FIELD";
         message = `Missing required field${pathDisplay}: ${firstError.message}`;
-        suggestions.push(`Field "${path13}" is required and must be of type "${expected}"`);
+        suggestions.push(`Field "${path20}" is required and must be of type "${expected}"`);
       } else {
         code = "INVALID_TYPE";
         message = `Invalid type${pathDisplay}: ${firstError.message}`;
@@ -2046,30 +2057,27 @@ function extractSections(content) {
     return result;
   });
 }
-function isExternalLink(path13) {
-  return path13.startsWith("http://") || path13.startsWith("https://") || path13.startsWith("#") || path13.startsWith("mailto:");
+function isExternalLink(path20) {
+  return path20.startsWith("http://") || path20.startsWith("https://") || path20.startsWith("#") || path20.startsWith("mailto:");
 }
 function resolveLinkPath(linkPath, baseDir) {
   return linkPath.startsWith(".") ? join4(baseDir, linkPath) : linkPath;
 }
-async function validateAgentsMap(path13 = "./AGENTS.md") {
-  console.warn(
-    "[harness] validateAgentsMap() is deprecated. Use graph-based validation via Assembler.checkCoverage() from @harness-engineering/graph"
-  );
-  const contentResult = await readFileContent(path13);
+async function validateAgentsMap(path20 = "./AGENTS.md") {
+  const contentResult = await readFileContent(path20);
   if (!contentResult.ok) {
     return Err(
       createError(
         "PARSE_ERROR",
         `Failed to read AGENTS.md: ${contentResult.error.message}`,
-        { path: path13 },
+        { path: path20 },
         ["Ensure the file exists", "Check file permissions"]
       )
     );
   }
   const content = contentResult.value;
   const sections = extractSections(content);
-  const baseDir = dirname4(path13);
+  const baseDir = dirname4(path20);
   const sectionTitles = sections.map((s) => s.title);
   const missingSections = REQUIRED_SECTIONS.filter(
     (required) => !sectionTitles.some((title) => title.toLowerCase().includes(required.toLowerCase()))
@@ -2146,7 +2154,7 @@ async function checkDocCoverage(domain, options = {}) {
   try {
     const sourceFiles = await findFiles("**/*.{ts,js,tsx,jsx}", sourceDir);
     const filteredSourceFiles = sourceFiles.filter((file) => {
-      const relativePath = relative9(sourceDir, file);
+      const relativePath = relativePosix(sourceDir, file);
       return !excludePatterns.some((pattern) => {
         return minimatch2(relativePath, pattern, { dot: true }) || minimatch2(file, pattern, { dot: true });
       });
@@ -2169,7 +2177,7 @@ async function checkDocCoverage(domain, options = {}) {
     const undocumented = [];
     const gaps = [];
     for (const sourceFile of filteredSourceFiles) {
-      const relativePath = relative9(sourceDir, sourceFile);
+      const relativePath = relativePosix(sourceDir, sourceFile);
       const fileName = basename(sourceFile);
       const isDocumented = documentedPaths.has(relativePath) || documentedPaths.has(fileName) || documentedPaths.has(`src/${relativePath}`);
       if (isDocumented) {
@@ -2203,8 +2211,8 @@ async function checkDocCoverage(domain, options = {}) {
     );
   }
 }
-function suggestFix(path13, existingFiles) {
-  const targetName = basename2(path13).toLowerCase();
+function suggestFix(path20, existingFiles) {
+  const targetName = basename2(path20).toLowerCase();
   const similar = existingFiles.find((file) => {
     const fileName = basename2(file).toLowerCase();
     return fileName.includes(targetName) || targetName.includes(fileName);
@@ -2212,12 +2220,9 @@ function suggestFix(path13, existingFiles) {
   if (similar) {
     return `Did you mean "${similar}"?`;
   }
-  return `Create the file "${path13}" or remove the link`;
+  return `Create the file "${path20}" or remove the link`;
 }
 async function validateKnowledgeMap(rootDir = process.cwd()) {
-  console.warn(
-    "[harness] validateKnowledgeMap() is deprecated. Use graph-based validation via Assembler.checkCoverage() from @harness-engineering/graph"
-  );
   const agentsPath = join22(rootDir, "AGENTS.md");
   const agentsResult = await validateAgentsMap(agentsPath);
   if (!agentsResult.ok) {
@@ -2229,7 +2234,7 @@ async function validateKnowledgeMap(rootDir = process.cwd()) {
     totalLinks: agentsTotalLinks
   } = agentsResult.value;
   const existingFiles = await findFiles("**/*", rootDir);
-  const relativeExistingFiles = existingFiles.map((f) => relative22(rootDir, f));
+  const relativeExistingFiles = existingFiles.map((f) => relativePosix(rootDir, f));
   const brokenLinks = agentsBrokenLinks.map((link) => {
     const section = sections.find(
       (s) => s.links.some((l) => l.path === link.path && l.line === link.line)
@@ -2267,7 +2272,7 @@ var DEFAULT_SECTIONS = [
 function groupByDirectory(files, rootDir) {
   const groups = /* @__PURE__ */ new Map();
   for (const file of files) {
-    const relativePath = relative32(rootDir, file);
+    const relativePath = relativePosix(rootDir, file);
     const dir = dirname22(relativePath);
     if (!groups.has(dir)) {
       groups.set(dir, []);
@@ -2323,7 +2328,7 @@ async function generateAgentsMap(config, graphSections) {
         allFiles.push(...files);
       }
       const filteredFiles = allFiles.filter((file) => {
-        const relativePath = relative32(rootDir, file);
+        const relativePath = relativePosix(rootDir, file);
         return !matchesExcludePattern(relativePath, excludePaths);
       });
       lines.push("## Repository Structure");
@@ -2351,11 +2356,11 @@ async function generateAgentsMap(config, graphSections) {
         }
         const sectionFiles = await findFiles(section.pattern, rootDir);
         const filteredSectionFiles = sectionFiles.filter((file) => {
-          const relativePath = relative32(rootDir, file);
+          const relativePath = relativePosix(rootDir, file);
           return !matchesExcludePattern(relativePath, excludePaths);
         });
         for (const file of filteredSectionFiles.slice(0, 20)) {
-          lines.push(formatFileLink(relative32(rootDir, file)));
+          lines.push(formatFileLink(relativePosix(rootDir, file)));
         }
         if (filteredSectionFiles.length > 20) {
           lines.push(`- _... and ${filteredSectionFiles.length - 20} more files_`);
@@ -2558,8 +2563,8 @@ function createBoundaryValidator(schema, name) {
         return Ok(result.data);
       }
       const suggestions = result.error.issues.map((issue) => {
-        const path13 = issue.path.join(".");
-        return path13 ? `${path13}: ${issue.message}` : issue.message;
+        const path20 = issue.path.join(".");
+        return path20 ? `${path20}: ${issue.message}` : issue.message;
       });
       return Err(
         createError(
@@ -3089,11 +3094,11 @@ function walk(node, visitor) {
 var TypeScriptParser = class {
   name = "typescript";
   extensions = [".ts", ".tsx", ".mts", ".cts"];
-  async parseFile(path13) {
-    const contentResult = await readFileContent(path13);
+  async parseFile(path20) {
+    const contentResult = await readFileContent(path20);
     if (!contentResult.ok) {
       return Err(
-        createParseError("NOT_FOUND", `File not found: ${path13}`, { path: path13 }, [
+        createParseError("NOT_FOUND", `File not found: ${path20}`, { path: path20 }, [
           "Check that the file exists",
           "Verify the path is correct"
         ])
@@ -3103,7 +3108,7 @@ var TypeScriptParser = class {
       const ast = parse(contentResult.value, {
         loc: true,
         range: true,
-        jsx: path13.endsWith(".tsx"),
+        jsx: path20.endsWith(".tsx"),
         errorOnUnknownASTType: false
       });
       return Ok({
@@ -3114,7 +3119,7 @@ var TypeScriptParser = class {
     } catch (e) {
       const error = e;
       return Err(
-        createParseError("SYNTAX_ERROR", `Failed to parse ${path13}: ${error.message}`, { path: path13 }, [
+        createParseError("SYNTAX_ERROR", `Failed to parse ${path20}: ${error.message}`, { path: path20 }, [
           "Check for syntax errors in the file",
           "Ensure valid TypeScript syntax"
         ])
@@ -3394,22 +3399,22 @@ function extractInlineRefs(content) {
   }
   return refs;
 }
-async function parseDocumentationFile(path13) {
-  const contentResult = await readFileContent(path13);
+async function parseDocumentationFile(path20) {
+  const contentResult = await readFileContent(path20);
   if (!contentResult.ok) {
     return Err(
       createEntropyError(
         "PARSE_ERROR",
-        `Failed to read documentation file: ${path13}`,
-        { file: path13 },
+        `Failed to read documentation file: ${path20}`,
+        { file: path20 },
         ["Check that the file exists"]
       )
     );
   }
   const content = contentResult.value;
-  const type = path13.endsWith(".md") ? "markdown" : "text";
+  const type = path20.endsWith(".md") ? "markdown" : "text";
   return Ok({
-    path: path13,
+    path: path20,
     type,
     content,
     codeBlocks: extractCodeBlocks(content),
@@ -3540,7 +3545,7 @@ async function buildSnapshot(config) {
     sourceFilePaths.push(...files2);
   }
   sourceFilePaths = sourceFilePaths.filter((f) => {
-    const rel = relative42(rootDir, f);
+    const rel = relativePosix(rootDir, f);
     return !excludePatterns.some((p) => minimatch22(rel, p));
   });
   const files = [];
@@ -4064,7 +4069,7 @@ async function detectDeadCode(snapshot, graphDeadCodeData) {
   return Ok(report);
 }
 function fileMatchesPattern(filePath, pattern, rootDir) {
-  const relativePath = relative52(rootDir, filePath);
+  const relativePath = relativePosix(rootDir, filePath);
   return minimatch3(relativePath, pattern);
 }
 function checkConfigPattern(pattern, file, rootDir) {
@@ -4210,15 +4215,34 @@ async function detectPatternViolations(snapshot, config) {
       }
     }
   }
+  if (config?.customPatterns) {
+    for (const file of snapshot.files) {
+      for (const custom of config.customPatterns) {
+        const matches = custom.check(file, snapshot);
+        for (const match of matches) {
+          violations.push({
+            pattern: custom.name,
+            file: file.path,
+            line: match.line,
+            message: match.message,
+            suggestion: match.suggestion || "Review and fix this pattern violation",
+            severity: custom.severity
+          });
+        }
+      }
+    }
+  }
   const errorCount = violations.filter((v) => v.severity === "error").length;
   const warningCount = violations.filter((v) => v.severity === "warning").length;
-  const totalChecks = snapshot.files.length * patterns.length;
-  const passRate = totalChecks > 0 ? (totalChecks - violations.length) / totalChecks : 1;
+  const customCount = config?.customPatterns?.length ?? 0;
+  const allPatternsCount = patterns.length + customCount;
+  const totalChecks = snapshot.files.length * allPatternsCount;
+  const passRate = totalChecks > 0 ? Math.max(0, (totalChecks - violations.length) / totalChecks) : 1;
   return Ok({
     violations,
     stats: {
       filesChecked: snapshot.files.length,
-      patternsApplied: patterns.length,
+      patternsApplied: allPatternsCount,
       violationCount: violations.length,
       errorCount,
       warningCount
@@ -6349,8 +6373,16 @@ var DEFAULT_STREAM_INDEX = {
   streams: {}
 };
 var HARNESS_DIR = ".harness";
-var STREAMS_DIR = "streams";
+var STATE_FILE = "state.json";
+var LEARNINGS_FILE = "learnings.md";
+var FAILURES_FILE = "failures.md";
+var HANDOFF_FILE = "handoff.json";
+var GATE_CONFIG_FILE = "gate.json";
 var INDEX_FILE = "index.json";
+var SESSIONS_DIR = "sessions";
+var SESSION_INDEX_FILE = "index.md";
+var SUMMARY_FILE = "summary.md";
+var STREAMS_DIR = "streams";
 var STREAM_NAME_REGEX = /^[a-z0-9][a-z0-9._-]*$/;
 function streamsDir(projectPath) {
   return path2.join(projectPath, HARNESS_DIR, STREAMS_DIR);
@@ -6576,25 +6608,60 @@ async function migrateToStreams(projectPath) {
   };
   return saveStreamIndex(projectPath, index);
 }
-var HARNESS_DIR2 = ".harness";
-var STATE_FILE = "state.json";
-var LEARNINGS_FILE = "learnings.md";
-var FAILURES_FILE = "failures.md";
-var HANDOFF_FILE = "handoff.json";
-var GATE_CONFIG_FILE = "gate.json";
-var INDEX_FILE2 = "index.json";
+function resolveSessionDir(projectPath, sessionSlug, options) {
+  if (!sessionSlug || sessionSlug.trim() === "") {
+    return Err(new Error("Session slug must not be empty"));
+  }
+  if (sessionSlug.includes("..") || sessionSlug.includes("/") || sessionSlug.includes("\\")) {
+    return Err(
+      new Error(`Invalid session slug '${sessionSlug}': must not contain path traversal characters`)
+    );
+  }
+  const sessionDir = path3.join(projectPath, HARNESS_DIR, SESSIONS_DIR, sessionSlug);
+  if (options?.create) {
+    fs6.mkdirSync(sessionDir, { recursive: true });
+  }
+  return Ok(sessionDir);
+}
+function updateSessionIndex(projectPath, sessionSlug, description) {
+  const sessionsDir = path3.join(projectPath, HARNESS_DIR, SESSIONS_DIR);
+  fs6.mkdirSync(sessionsDir, { recursive: true });
+  const indexPath2 = path3.join(sessionsDir, SESSION_INDEX_FILE);
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const newLine = `- [${sessionSlug}](${sessionSlug}/summary.md) \u2014 ${description} (${date})`;
+  if (!fs6.existsSync(indexPath2)) {
+    fs6.writeFileSync(indexPath2, `## Active Sessions
+
+${newLine}
+`);
+    return;
+  }
+  const content = fs6.readFileSync(indexPath2, "utf-8");
+  const lines = content.split("\n");
+  const slugPattern = `- [${sessionSlug}]`;
+  const existingIdx = lines.findIndex((l) => l.startsWith(slugPattern));
+  if (existingIdx >= 0) {
+    lines[existingIdx] = newLine;
+  } else {
+    const lastNonEmpty = lines.reduce((last, line, i) => line.trim() !== "" ? i : last, 0);
+    lines.splice(lastNonEmpty + 1, 0, newLine);
+  }
+  fs6.writeFileSync(indexPath2, lines.join("\n"));
+}
 var MAX_CACHE_ENTRIES = 8;
-var learningsCacheMap = /* @__PURE__ */ new Map();
-var failuresCacheMap = /* @__PURE__ */ new Map();
 function evictIfNeeded(map) {
   if (map.size > MAX_CACHE_ENTRIES) {
     const oldest = map.keys().next().value;
     if (oldest !== void 0) map.delete(oldest);
   }
 }
-async function getStateDir(projectPath, stream) {
-  const streamsIndexPath = path3.join(projectPath, HARNESS_DIR2, "streams", INDEX_FILE2);
-  const hasStreams = fs6.existsSync(streamsIndexPath);
+async function getStateDir(projectPath, stream, session) {
+  if (session) {
+    const sessionResult = resolveSessionDir(projectPath, session, { create: true });
+    return sessionResult;
+  }
+  const streamsIndexPath = path4.join(projectPath, HARNESS_DIR, "streams", INDEX_FILE);
+  const hasStreams = fs7.existsSync(streamsIndexPath);
   if (stream || hasStreams) {
     const result = await resolveStreamPath(projectPath, stream ? { stream } : void 0);
     if (result.ok) {
@@ -6604,18 +6671,18 @@ async function getStateDir(projectPath, stream) {
       return result;
     }
   }
-  return Ok(path3.join(projectPath, HARNESS_DIR2));
+  return Ok(path4.join(projectPath, HARNESS_DIR));
 }
-async function loadState(projectPath, stream) {
+async function loadState(projectPath, stream, session) {
   try {
-    const dirResult = await getStateDir(projectPath, stream);
+    const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const statePath = path3.join(stateDir, STATE_FILE);
-    if (!fs6.existsSync(statePath)) {
+    const statePath = path5.join(stateDir, STATE_FILE);
+    if (!fs8.existsSync(statePath)) {
       return Ok({ ...DEFAULT_STATE });
     }
-    const raw = fs6.readFileSync(statePath, "utf-8");
+    const raw = fs8.readFileSync(statePath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = HarnessStateSchema.safeParse(parsed);
     if (!result.success) {
@@ -6628,14 +6695,14 @@ async function loadState(projectPath, stream) {
     );
   }
 }
-async function saveState(projectPath, state, stream) {
+async function saveState(projectPath, state, stream, session) {
   try {
-    const dirResult = await getStateDir(projectPath, stream);
+    const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const statePath = path3.join(stateDir, STATE_FILE);
-    fs6.mkdirSync(stateDir, { recursive: true });
-    fs6.writeFileSync(statePath, JSON.stringify(state, null, 2));
+    const statePath = path5.join(stateDir, STATE_FILE);
+    fs8.mkdirSync(stateDir, { recursive: true });
+    fs8.writeFileSync(statePath, JSON.stringify(state, null, 2));
     return Ok(void 0);
   } catch (error) {
     return Err(
@@ -6643,13 +6710,17 @@ async function saveState(projectPath, state, stream) {
     );
   }
 }
-async function appendLearning(projectPath, learning, skillName, outcome, stream) {
+var learningsCacheMap = /* @__PURE__ */ new Map();
+function clearLearningsCache() {
+  learningsCacheMap.clear();
+}
+async function appendLearning(projectPath, learning, skillName, outcome, stream, session) {
   try {
-    const dirResult = await getStateDir(projectPath, stream);
+    const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const learningsPath = path3.join(stateDir, LEARNINGS_FILE);
-    fs6.mkdirSync(stateDir, { recursive: true });
+    const learningsPath = path6.join(stateDir, LEARNINGS_FILE);
+    fs9.mkdirSync(stateDir, { recursive: true });
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     let entry;
     if (skillName && outcome) {
@@ -6665,11 +6736,11 @@ async function appendLearning(projectPath, learning, skillName, outcome, stream)
 - **${timestamp}:** ${learning}
 `;
     }
-    if (!fs6.existsSync(learningsPath)) {
-      fs6.writeFileSync(learningsPath, `# Learnings
+    if (!fs9.existsSync(learningsPath)) {
+      fs9.writeFileSync(learningsPath, `# Learnings
 ${entry}`);
     } else {
-      fs6.appendFileSync(learningsPath, entry);
+      fs9.appendFileSync(learningsPath, entry);
     }
     learningsCacheMap.delete(learningsPath);
     return Ok(void 0);
@@ -6681,23 +6752,92 @@ ${entry}`);
     );
   }
 }
-async function loadRelevantLearnings(projectPath, skillName, stream) {
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function scoreRelevance(entry, intent) {
+  if (!intent || intent.trim() === "") return 0;
+  const intentWords = intent.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+  if (intentWords.length === 0) return 0;
+  const entryLower = entry.toLowerCase();
+  const matches = intentWords.filter((word) => entryLower.includes(word));
+  return matches.length / intentWords.length;
+}
+function parseDateFromEntry(entry) {
+  const match = entry.match(/(\d{4}-\d{2}-\d{2})/);
+  return match ? match[1] ?? null : null;
+}
+function analyzeLearningPatterns(entries) {
+  const tagGroups = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const tagMatches = entry.matchAll(/\[(skill:[^\]]+)\]|\[(outcome:[^\]]+)\]/g);
+    for (const match of tagMatches) {
+      const tag = match[1] ?? match[2];
+      if (tag) {
+        const group = tagGroups.get(tag) ?? [];
+        group.push(entry);
+        tagGroups.set(tag, group);
+      }
+    }
+  }
+  const patterns = [];
+  for (const [tag, groupEntries] of tagGroups) {
+    if (groupEntries.length >= 3) {
+      patterns.push({ tag, count: groupEntries.length, entries: groupEntries });
+    }
+  }
+  return patterns.sort((a, b) => b.count - a.count);
+}
+async function loadBudgetedLearnings(projectPath, options) {
+  const { intent, tokenBudget = 1e3, skill, session, stream } = options;
+  const sortByRecencyAndRelevance = (entries) => {
+    return [...entries].sort((a, b) => {
+      const dateA = parseDateFromEntry(a) ?? "0000-00-00";
+      const dateB = parseDateFromEntry(b) ?? "0000-00-00";
+      const dateCompare = dateB.localeCompare(dateA);
+      if (dateCompare !== 0) return dateCompare;
+      return scoreRelevance(b, intent) - scoreRelevance(a, intent);
+    });
+  };
+  const allEntries = [];
+  if (session) {
+    const sessionResult = await loadRelevantLearnings(projectPath, skill, stream, session);
+    if (sessionResult.ok) {
+      allEntries.push(...sortByRecencyAndRelevance(sessionResult.value));
+    }
+  }
+  const globalResult = await loadRelevantLearnings(projectPath, skill, stream);
+  if (globalResult.ok) {
+    allEntries.push(...sortByRecencyAndRelevance(globalResult.value));
+  }
+  const budgeted = [];
+  let totalTokens = 0;
+  for (const entry of allEntries) {
+    const separator = budgeted.length > 0 ? "\n" : "";
+    const entryCost = estimateTokens(entry + separator);
+    if (totalTokens + entryCost > tokenBudget) break;
+    budgeted.push(entry);
+    totalTokens += entryCost;
+  }
+  return Ok(budgeted);
+}
+async function loadRelevantLearnings(projectPath, skillName, stream, session) {
   try {
-    const dirResult = await getStateDir(projectPath, stream);
+    const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const learningsPath = path3.join(stateDir, LEARNINGS_FILE);
-    if (!fs6.existsSync(learningsPath)) {
+    const learningsPath = path6.join(stateDir, LEARNINGS_FILE);
+    if (!fs9.existsSync(learningsPath)) {
       return Ok([]);
     }
-    const stats = fs6.statSync(learningsPath);
+    const stats = fs9.statSync(learningsPath);
     const cacheKey = learningsPath;
     const cached = learningsCacheMap.get(cacheKey);
     let entries;
     if (cached && cached.mtimeMs === stats.mtimeMs) {
       entries = cached.entries;
     } else {
-      const content = fs6.readFileSync(learningsPath, "utf-8");
+      const content = fs9.readFileSync(learningsPath, "utf-8");
       const lines = content.split("\n");
       entries = [];
       let currentBlock = [];
@@ -6733,23 +6873,106 @@ async function loadRelevantLearnings(projectPath, skillName, stream) {
     );
   }
 }
-var FAILURE_LINE_REGEX = /^- \*\*(\d{4}-\d{2}-\d{2}) \[skill:([^\]]+)\] \[type:([^\]]+)\]:\*\* (.+)$/;
-async function appendFailure(projectPath, description, skillName, type, stream) {
+async function archiveLearnings(projectPath, entries, stream) {
+  try {
+    const dirResult = await getStateDir(projectPath, stream);
+    if (!dirResult.ok) return dirResult;
+    const stateDir = dirResult.value;
+    const archiveDir = path6.join(stateDir, "learnings-archive");
+    fs9.mkdirSync(archiveDir, { recursive: true });
+    const now = /* @__PURE__ */ new Date();
+    const yearMonth = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`;
+    const archivePath = path6.join(archiveDir, `${yearMonth}.md`);
+    const archiveContent = entries.join("\n\n") + "\n";
+    if (fs9.existsSync(archivePath)) {
+      fs9.appendFileSync(archivePath, "\n" + archiveContent);
+    } else {
+      fs9.writeFileSync(archivePath, `# Learnings Archive
+
+${archiveContent}`);
+    }
+    return Ok(void 0);
+  } catch (error) {
+    return Err(
+      new Error(
+        `Failed to archive learnings: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+async function pruneLearnings(projectPath, stream) {
   try {
     const dirResult = await getStateDir(projectPath, stream);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const failuresPath = path3.join(stateDir, FAILURES_FILE);
-    fs6.mkdirSync(stateDir, { recursive: true });
+    const learningsPath = path6.join(stateDir, LEARNINGS_FILE);
+    if (!fs9.existsSync(learningsPath)) {
+      return Ok({ kept: 0, archived: 0, patterns: [] });
+    }
+    const loadResult = await loadRelevantLearnings(projectPath, void 0, stream);
+    if (!loadResult.ok) return loadResult;
+    const allEntries = loadResult.value;
+    if (allEntries.length <= 20) {
+      const cutoffDate = /* @__PURE__ */ new Date();
+      cutoffDate.setDate(cutoffDate.getDate() - 14);
+      const cutoffStr = cutoffDate.toISOString().split("T")[0];
+      const hasOld = allEntries.some((entry) => {
+        const date = parseDateFromEntry(entry);
+        return date !== null && date < cutoffStr;
+      });
+      if (!hasOld) {
+        return Ok({ kept: allEntries.length, archived: 0, patterns: [] });
+      }
+    }
+    const sorted = [...allEntries].sort((a, b) => {
+      const dateA = parseDateFromEntry(a) ?? "0000-00-00";
+      const dateB = parseDateFromEntry(b) ?? "0000-00-00";
+      return dateB.localeCompare(dateA);
+    });
+    const toKeep = sorted.slice(0, 20);
+    const toArchive = sorted.slice(20);
+    const patterns = analyzeLearningPatterns(allEntries);
+    if (toArchive.length > 0) {
+      const archiveResult = await archiveLearnings(projectPath, toArchive, stream);
+      if (!archiveResult.ok) return archiveResult;
+    }
+    const newContent = "# Learnings\n\n" + toKeep.join("\n\n") + "\n";
+    fs9.writeFileSync(learningsPath, newContent);
+    learningsCacheMap.delete(learningsPath);
+    return Ok({
+      kept: toKeep.length,
+      archived: toArchive.length,
+      patterns
+    });
+  } catch (error) {
+    return Err(
+      new Error(
+        `Failed to prune learnings: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+var failuresCacheMap = /* @__PURE__ */ new Map();
+function clearFailuresCache() {
+  failuresCacheMap.clear();
+}
+var FAILURE_LINE_REGEX = /^- \*\*(\d{4}-\d{2}-\d{2}) \[skill:([^\]]+)\] \[type:([^\]]+)\]:\*\* (.+)$/;
+async function appendFailure(projectPath, description, skillName, type, stream, session) {
+  try {
+    const dirResult = await getStateDir(projectPath, stream, session);
+    if (!dirResult.ok) return dirResult;
+    const stateDir = dirResult.value;
+    const failuresPath = path7.join(stateDir, FAILURES_FILE);
+    fs10.mkdirSync(stateDir, { recursive: true });
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     const entry = `
 - **${timestamp} [skill:${skillName}] [type:${type}]:** ${description}
 `;
-    if (!fs6.existsSync(failuresPath)) {
-      fs6.writeFileSync(failuresPath, `# Failures
+    if (!fs10.existsSync(failuresPath)) {
+      fs10.writeFileSync(failuresPath, `# Failures
 ${entry}`);
     } else {
-      fs6.appendFileSync(failuresPath, entry);
+      fs10.appendFileSync(failuresPath, entry);
     }
     failuresCacheMap.delete(failuresPath);
     return Ok(void 0);
@@ -6761,22 +6984,22 @@ ${entry}`);
     );
   }
 }
-async function loadFailures(projectPath, stream) {
+async function loadFailures(projectPath, stream, session) {
   try {
-    const dirResult = await getStateDir(projectPath, stream);
+    const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const failuresPath = path3.join(stateDir, FAILURES_FILE);
-    if (!fs6.existsSync(failuresPath)) {
+    const failuresPath = path7.join(stateDir, FAILURES_FILE);
+    if (!fs10.existsSync(failuresPath)) {
       return Ok([]);
     }
-    const stats = fs6.statSync(failuresPath);
+    const stats = fs10.statSync(failuresPath);
     const cacheKey = failuresPath;
     const cached = failuresCacheMap.get(cacheKey);
     if (cached && cached.mtimeMs === stats.mtimeMs) {
       return Ok(cached.entries);
     }
-    const content = fs6.readFileSync(failuresPath, "utf-8");
+    const content = fs10.readFileSync(failuresPath, "utf-8");
     const entries = [];
     for (const line of content.split("\n")) {
       const match = line.match(FAILURE_LINE_REGEX);
@@ -6800,25 +7023,25 @@ async function loadFailures(projectPath, stream) {
     );
   }
 }
-async function archiveFailures(projectPath, stream) {
+async function archiveFailures(projectPath, stream, session) {
   try {
-    const dirResult = await getStateDir(projectPath, stream);
+    const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const failuresPath = path3.join(stateDir, FAILURES_FILE);
-    if (!fs6.existsSync(failuresPath)) {
+    const failuresPath = path7.join(stateDir, FAILURES_FILE);
+    if (!fs10.existsSync(failuresPath)) {
       return Ok(void 0);
     }
-    const archiveDir = path3.join(stateDir, "archive");
-    fs6.mkdirSync(archiveDir, { recursive: true });
+    const archiveDir = path7.join(stateDir, "archive");
+    fs10.mkdirSync(archiveDir, { recursive: true });
     const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     let archiveName = `failures-${date}.md`;
     let counter = 2;
-    while (fs6.existsSync(path3.join(archiveDir, archiveName))) {
+    while (fs10.existsSync(path7.join(archiveDir, archiveName))) {
       archiveName = `failures-${date}-${counter}.md`;
       counter++;
     }
-    fs6.renameSync(failuresPath, path3.join(archiveDir, archiveName));
+    fs10.renameSync(failuresPath, path7.join(archiveDir, archiveName));
     failuresCacheMap.delete(failuresPath);
     return Ok(void 0);
   } catch (error) {
@@ -6829,14 +7052,14 @@ async function archiveFailures(projectPath, stream) {
     );
   }
 }
-async function saveHandoff(projectPath, handoff, stream) {
+async function saveHandoff(projectPath, handoff, stream, session) {
   try {
-    const dirResult = await getStateDir(projectPath, stream);
+    const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const handoffPath = path3.join(stateDir, HANDOFF_FILE);
-    fs6.mkdirSync(stateDir, { recursive: true });
-    fs6.writeFileSync(handoffPath, JSON.stringify(handoff, null, 2));
+    const handoffPath = path8.join(stateDir, HANDOFF_FILE);
+    fs11.mkdirSync(stateDir, { recursive: true });
+    fs11.writeFileSync(handoffPath, JSON.stringify(handoff, null, 2));
     return Ok(void 0);
   } catch (error) {
     return Err(
@@ -6844,16 +7067,16 @@ async function saveHandoff(projectPath, handoff, stream) {
     );
   }
 }
-async function loadHandoff(projectPath, stream) {
+async function loadHandoff(projectPath, stream, session) {
   try {
-    const dirResult = await getStateDir(projectPath, stream);
+    const dirResult = await getStateDir(projectPath, stream, session);
     if (!dirResult.ok) return dirResult;
     const stateDir = dirResult.value;
-    const handoffPath = path3.join(stateDir, HANDOFF_FILE);
-    if (!fs6.existsSync(handoffPath)) {
+    const handoffPath = path8.join(stateDir, HANDOFF_FILE);
+    if (!fs11.existsSync(handoffPath)) {
       return Ok(null);
     }
-    const raw = fs6.readFileSync(handoffPath, "utf-8");
+    const raw = fs11.readFileSync(handoffPath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = HandoffSchema.safeParse(parsed);
     if (!result.success) {
@@ -6866,73 +7089,77 @@ async function loadHandoff(projectPath, stream) {
     );
   }
 }
+var SAFE_GATE_COMMAND = /^(?:npm|pnpm|yarn)\s+(?:test|run\s+[\w.-]+|run-script\s+[\w.-]+)$|^go\s+(?:test|build|vet|fmt)\s+[\w./ -]+$|^(?:python|python3)\s+-m\s+[\w.-]+$|^make\s+[\w.-]+$|^cargo\s+(?:test|build|check|clippy)(?:\s+[\w./ -]+)?$|^(?:gradle|mvn)\s+[\w:.-]+$/;
+function loadChecksFromConfig(gateConfigPath) {
+  if (!fs12.existsSync(gateConfigPath)) return [];
+  const raw = JSON.parse(fs12.readFileSync(gateConfigPath, "utf-8"));
+  const config = GateConfigSchema.safeParse(raw);
+  if (config.success && config.data.checks) return config.data.checks;
+  return [];
+}
+function discoverChecksFromProject(projectPath) {
+  const checks = [];
+  const packageJsonPath = path9.join(projectPath, "package.json");
+  if (fs12.existsSync(packageJsonPath)) {
+    const pkg = JSON.parse(fs12.readFileSync(packageJsonPath, "utf-8"));
+    const scripts = pkg.scripts || {};
+    if (scripts.test) checks.push({ name: "test", command: "npm test" });
+    if (scripts.lint) checks.push({ name: "lint", command: "npm run lint" });
+    if (scripts.typecheck) checks.push({ name: "typecheck", command: "npm run typecheck" });
+    if (scripts.build) checks.push({ name: "build", command: "npm run build" });
+  }
+  if (fs12.existsSync(path9.join(projectPath, "go.mod"))) {
+    checks.push({ name: "test", command: "go test ./..." });
+    checks.push({ name: "build", command: "go build ./..." });
+  }
+  if (fs12.existsSync(path9.join(projectPath, "pyproject.toml")) || fs12.existsSync(path9.join(projectPath, "setup.py"))) {
+    checks.push({ name: "test", command: "python -m pytest" });
+  }
+  return checks;
+}
+function executeCheck(check, projectPath) {
+  if (!SAFE_GATE_COMMAND.test(check.command)) {
+    return {
+      name: check.name,
+      passed: false,
+      command: check.command,
+      output: `Blocked: command does not match safe gate pattern. Allowed prefixes: npm, pnpm, yarn, go, python, python3, make, cargo, gradle, mvn`,
+      duration: 0
+    };
+  }
+  const start = Date.now();
+  try {
+    execSync2(check.command, {
+      cwd: projectPath,
+      stdio: "pipe",
+      timeout: 12e4
+    });
+    return {
+      name: check.name,
+      passed: true,
+      command: check.command,
+      duration: Date.now() - start
+    };
+  } catch (error) {
+    const output = error instanceof Error ? error.stderr?.toString() || error.message : String(error);
+    return {
+      name: check.name,
+      passed: false,
+      command: check.command,
+      output: output.slice(0, 2e3),
+      duration: Date.now() - start
+    };
+  }
+}
 async function runMechanicalGate(projectPath) {
-  const harnessDir = path3.join(projectPath, HARNESS_DIR2);
-  const gateConfigPath = path3.join(harnessDir, GATE_CONFIG_FILE);
+  const harnessDir = path9.join(projectPath, HARNESS_DIR);
+  const gateConfigPath = path9.join(harnessDir, GATE_CONFIG_FILE);
   try {
-    let checks = [];
-    if (fs6.existsSync(gateConfigPath)) {
-      const raw = JSON.parse(fs6.readFileSync(gateConfigPath, "utf-8"));
-      const config = GateConfigSchema.safeParse(raw);
-      if (config.success && config.data.checks) {
-        checks = config.data.checks;
-      }
-    }
+    let checks = loadChecksFromConfig(gateConfigPath);
     if (checks.length === 0) {
-      const packageJsonPath = path3.join(projectPath, "package.json");
-      if (fs6.existsSync(packageJsonPath)) {
-        const pkg = JSON.parse(fs6.readFileSync(packageJsonPath, "utf-8"));
-        const scripts = pkg.scripts || {};
-        if (scripts.test) checks.push({ name: "test", command: "npm test" });
-        if (scripts.lint) checks.push({ name: "lint", command: "npm run lint" });
-        if (scripts.typecheck) checks.push({ name: "typecheck", command: "npm run typecheck" });
-        if (scripts.build) checks.push({ name: "build", command: "npm run build" });
-      }
-      if (fs6.existsSync(path3.join(projectPath, "go.mod"))) {
-        checks.push({ name: "test", command: "go test ./..." });
-        checks.push({ name: "build", command: "go build ./..." });
-      }
-      if (fs6.existsSync(path3.join(projectPath, "pyproject.toml")) || fs6.existsSync(path3.join(projectPath, "setup.py"))) {
-        checks.push({ name: "test", command: "python -m pytest" });
-      }
-    }
-    const results = [];
-    const SAFE_GATE_COMMAND = /^(?:npm|pnpm|yarn)\s+(?:test|run\s+[\w.-]+|run-script\s+[\w.-]+)$|^go\s+(?:test|build|vet|fmt)\s+[\w./ -]+$|^(?:python|python3)\s+-m\s+[\w.-]+$|^make\s+[\w.-]+$|^cargo\s+(?:test|build|check|clippy)(?:\s+[\w./ -]+)?$|^(?:gradle|mvn)\s+[\w:.-]+$/;
-    for (const check of checks) {
-      if (!SAFE_GATE_COMMAND.test(check.command)) {
-        results.push({
-          name: check.name,
-          passed: false,
-          command: check.command,
-          output: `Blocked: command does not match safe gate pattern. Allowed prefixes: npm, npx, pnpm, yarn, go, python, python3, make, cargo, gradle, mvn`,
-          duration: 0
-        });
-        continue;
-      }
-      const start = Date.now();
-      try {
-        execSync2(check.command, {
-          cwd: projectPath,
-          stdio: "pipe",
-          timeout: 12e4
-        });
-        results.push({
-          name: check.name,
-          passed: true,
-          command: check.command,
-          duration: Date.now() - start
-        });
-      } catch (error) {
-        const output = error instanceof Error ? error.stderr?.toString() || error.message : String(error);
-        results.push({
-          name: check.name,
-          passed: false,
-          command: check.command,
-          output: output.slice(0, 2e3),
-          duration: Date.now() - start
-        });
-      }
+      checks = discoverChecksFromProject(projectPath);
     }
+    const results = checks.map((check) => executeCheck(check, projectPath));
     return Ok({
       passed: results.length === 0 || results.every((r) => r.passed),
       checks: results
@@ -6945,6 +7172,92 @@ async function runMechanicalGate(projectPath) {
     );
   }
 }
+function formatSummary(data) {
+  const lines = [
+    "## Session Summary",
+    "",
+    `**Session:** ${data.session}`,
+    `**Last active:** ${data.lastActive}`,
+    `**Skill:** ${data.skill}`
+  ];
+  if (data.phase) {
+    lines.push(`**Phase:** ${data.phase}`);
+  }
+  lines.push(`**Status:** ${data.status}`);
+  if (data.spec) {
+    lines.push(`**Spec:** ${data.spec}`);
+  }
+  if (data.plan) {
+    lines.push(`**Plan:** ${data.plan}`);
+  }
+  lines.push(`**Key context:** ${data.keyContext}`);
+  lines.push(`**Next step:** ${data.nextStep}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function deriveIndexDescription(data) {
+  const skillShort = data.skill.replace("harness-", "");
+  const parts = [skillShort];
+  if (data.phase) {
+    parts.push(`phase ${data.phase}`);
+  }
+  parts.push(data.status.toLowerCase());
+  return parts.join(", ");
+}
+function writeSessionSummary(projectPath, sessionSlug, data) {
+  try {
+    const dirResult = resolveSessionDir(projectPath, sessionSlug, { create: true });
+    if (!dirResult.ok) return dirResult;
+    const sessionDir = dirResult.value;
+    const summaryPath = path10.join(sessionDir, SUMMARY_FILE);
+    const content = formatSummary(data);
+    fs13.writeFileSync(summaryPath, content);
+    const description = deriveIndexDescription(data);
+    updateSessionIndex(projectPath, sessionSlug, description);
+    return Ok(void 0);
+  } catch (error) {
+    return Err(
+      new Error(
+        `Failed to write session summary: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+function loadSessionSummary(projectPath, sessionSlug) {
+  try {
+    const dirResult = resolveSessionDir(projectPath, sessionSlug);
+    if (!dirResult.ok) return dirResult;
+    const sessionDir = dirResult.value;
+    const summaryPath = path10.join(sessionDir, SUMMARY_FILE);
+    if (!fs13.existsSync(summaryPath)) {
+      return Ok(null);
+    }
+    const content = fs13.readFileSync(summaryPath, "utf-8");
+    return Ok(content);
+  } catch (error) {
+    return Err(
+      new Error(
+        `Failed to load session summary: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+function listActiveSessions(projectPath) {
+  try {
+    const indexPath2 = path10.join(projectPath, HARNESS_DIR, SESSIONS_DIR, SESSION_INDEX_FILE);
+    if (!fs13.existsSync(indexPath2)) {
+      return Ok(null);
+    }
+    const content = fs13.readFileSync(indexPath2, "utf-8");
+    return Ok(content);
+  } catch (error) {
+    return Err(
+      new Error(
+        `Failed to list active sessions: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
 async function executeWorkflow(workflow, executor) {
   const stepResults = [];
   const startTime = Date.now();
@@ -7166,11 +7479,11 @@ function resolveRuleSeverity(ruleId, defaultSeverity, overrides, strict) {
 }
 function detectStack(projectRoot) {
   const stacks = [];
-  const pkgJsonPath = path4.join(projectRoot, "package.json");
-  if (fs7.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path11.join(projectRoot, "package.json");
+  if (fs14.existsSync(pkgJsonPath)) {
     stacks.push("node");
     try {
-      const pkgJson = JSON.parse(fs7.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs14.readFileSync(pkgJsonPath, "utf-8"));
       const allDeps = {
         ...pkgJson.dependencies,
         ...pkgJson.devDependencies
@@ -7185,13 +7498,13 @@ function detectStack(projectRoot) {
     } catch {
     }
   }
-  const goModPath = path4.join(projectRoot, "go.mod");
-  if (fs7.existsSync(goModPath)) {
+  const goModPath = path11.join(projectRoot, "go.mod");
+  if (fs14.existsSync(goModPath)) {
     stacks.push("go");
   }
-  const requirementsPath = path4.join(projectRoot, "requirements.txt");
-  const pyprojectPath = path4.join(projectRoot, "pyproject.toml");
-  if (fs7.existsSync(requirementsPath) || fs7.existsSync(pyprojectPath)) {
+  const requirementsPath = path11.join(projectRoot, "requirements.txt");
+  const pyprojectPath = path11.join(projectRoot, "pyproject.toml");
+  if (fs14.existsSync(requirementsPath) || fs14.existsSync(pyprojectPath)) {
     stacks.push("python");
   }
   return stacks;
@@ -7594,7 +7907,7 @@ var SecurityScanner = class {
   }
   async scanFile(filePath) {
     if (!this.config.enabled) return [];
-    const content = await fs8.readFile(filePath, "utf-8");
+    const content = await fs15.readFile(filePath, "utf-8");
     return this.scanContent(content, filePath, 1);
   }
   async scanFiles(filePaths) {
@@ -7627,238 +7940,270 @@ var ALL_CHECKS = [
   "phase-gate",
   "arch"
 ];
-async function runSingleCheck(name, projectRoot, config) {
-  const start = Date.now();
+async function runValidateCheck(projectRoot, config) {
   const issues = [];
-  try {
-    switch (name) {
-      case "validate": {
-        const agentsPath = path5.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
-        const result = await validateAgentsMap(agentsPath);
-        if (!result.ok) {
-          issues.push({ severity: "error", message: result.error.message });
-        } else if (!result.value.valid) {
-          if (result.value.errors) {
-            for (const err of result.value.errors) {
-              issues.push({ severity: "error", message: err.message });
-            }
-          }
-          for (const section of result.value.missingSections) {
-            issues.push({ severity: "warning", message: `Missing section: ${section}` });
-          }
-          for (const link of result.value.brokenLinks) {
-            issues.push({
-              severity: "warning",
-              message: `Broken link: ${link.text} \u2192 ${link.path}`,
-              file: link.path
-            });
-          }
-        }
-        break;
+  const agentsPath = path12.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
+  const result = await validateAgentsMap(agentsPath);
+  if (!result.ok) {
+    issues.push({ severity: "error", message: result.error.message });
+  } else if (!result.value.valid) {
+    if (result.value.errors) {
+      for (const err of result.value.errors) {
+        issues.push({ severity: "error", message: err.message });
       }
-      case "deps": {
-        const rawLayers = config.layers;
-        if (rawLayers && rawLayers.length > 0) {
-          const parser = new TypeScriptParser();
-          const layers = rawLayers.map(
-            (l) => defineLayer(
-              l.name,
-              Array.isArray(l.patterns) ? l.patterns : [l.pattern],
-              l.allowedDependencies
-            )
-          );
-          const result = await validateDependencies({
-            layers,
-            rootDir: projectRoot,
-            parser
-          });
-          if (!result.ok) {
-            issues.push({ severity: "error", message: result.error.message });
-          } else if (result.value.violations.length > 0) {
-            for (const v of result.value.violations) {
-              issues.push({
-                severity: "error",
-                message: `${v.reason}: ${v.file} imports ${v.imports} (${v.fromLayer} \u2192 ${v.toLayer})`,
-                file: v.file,
-                line: v.line
-              });
-            }
-          }
-        }
-        break;
+    }
+    for (const section of result.value.missingSections) {
+      issues.push({ severity: "warning", message: `Missing section: ${section}` });
+    }
+    for (const link of result.value.brokenLinks) {
+      issues.push({
+        severity: "warning",
+        message: `Broken link: ${link.text} \u2192 ${link.path}`,
+        file: link.path
+      });
+    }
+  }
+  return issues;
+}
+async function runDepsCheck(projectRoot, config) {
+  const issues = [];
+  const rawLayers = config.layers;
+  if (rawLayers && rawLayers.length > 0) {
+    const parser = new TypeScriptParser();
+    const layers = rawLayers.map(
+      (l) => defineLayer(
+        l.name,
+        Array.isArray(l.patterns) ? l.patterns : [l.pattern],
+        l.allowedDependencies
+      )
+    );
+    const result = await validateDependencies({
+      layers,
+      rootDir: projectRoot,
+      parser
+    });
+    if (!result.ok) {
+      issues.push({ severity: "error", message: result.error.message });
+    } else if (result.value.violations.length > 0) {
+      for (const v of result.value.violations) {
+        issues.push({
+          severity: "error",
+          message: `${v.reason}: ${v.file} imports ${v.imports} (${v.fromLayer} \u2192 ${v.toLayer})`,
+          file: v.file,
+          line: v.line
+        });
       }
-      case "docs": {
-        const docsDir = path5.join(projectRoot, config.docsDir ?? "docs");
-        const entropyConfig = config.entropy || {};
-        const result = await checkDocCoverage("project", {
-          docsDir,
-          sourceDir: projectRoot,
-          excludePatterns: entropyConfig.excludePatterns || [
-            "**/node_modules/**",
-            "**/dist/**",
-            "**/*.test.ts",
-            "**/fixtures/**"
-          ]
+    }
+  }
+  return issues;
+}
+async function runDocsCheck(projectRoot, config) {
+  const issues = [];
+  const docsDir = path12.join(projectRoot, config.docsDir ?? "docs");
+  const entropyConfig = config.entropy || {};
+  const result = await checkDocCoverage("project", {
+    docsDir,
+    sourceDir: projectRoot,
+    excludePatterns: entropyConfig.excludePatterns || [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/*.test.ts",
+      "**/fixtures/**"
+    ]
+  });
+  if (!result.ok) {
+    issues.push({ severity: "warning", message: result.error.message });
+  } else if (result.value.gaps.length > 0) {
+    for (const gap of result.value.gaps) {
+      issues.push({
+        severity: "warning",
+        message: `Undocumented: ${gap.file} (suggested: ${gap.suggestedSection})`,
+        file: gap.file
+      });
+    }
+  }
+  return issues;
+}
+async function runEntropyCheck(projectRoot, _config) {
+  const issues = [];
+  const analyzer = new EntropyAnalyzer({
+    rootDir: projectRoot,
+    analyze: { drift: true, deadCode: true, patterns: false }
+  });
+  const result = await analyzer.analyze();
+  if (!result.ok) {
+    issues.push({ severity: "warning", message: result.error.message });
+  } else {
+    const report = result.value;
+    if (report.drift) {
+      for (const drift of report.drift.drifts) {
+        issues.push({
+          severity: "warning",
+          message: `Doc drift (${drift.type}): ${drift.details}`,
+          file: drift.docFile,
+          line: drift.line
         });
-        if (!result.ok) {
-          issues.push({ severity: "warning", message: result.error.message });
-        } else if (result.value.gaps.length > 0) {
-          for (const gap of result.value.gaps) {
-            issues.push({
-              severity: "warning",
-              message: `Undocumented: ${gap.file} (suggested: ${gap.suggestedSection})`,
-              file: gap.file
-            });
-          }
-        }
-        break;
       }
-      case "entropy": {
-        const analyzer = new EntropyAnalyzer({
-          rootDir: projectRoot,
-          analyze: { drift: true, deadCode: true, patterns: false }
+    }
+    if (report.deadCode) {
+      for (const dead of report.deadCode.deadExports) {
+        issues.push({
+          severity: "warning",
+          message: `Dead export: ${dead.name}`,
+          file: dead.file,
+          line: dead.line
         });
-        const result = await analyzer.analyze();
-        if (!result.ok) {
-          issues.push({ severity: "warning", message: result.error.message });
-        } else {
-          const report = result.value;
-          if (report.drift) {
-            for (const drift of report.drift.drifts) {
-              issues.push({
-                severity: "warning",
-                message: `Doc drift (${drift.type}): ${drift.details}`,
-                file: drift.docFile,
-                line: drift.line
-              });
-            }
-          }
-          if (report.deadCode) {
-            for (const dead of report.deadCode.deadExports) {
-              issues.push({
-                severity: "warning",
-                message: `Dead export: ${dead.name}`,
-                file: dead.file,
-                line: dead.line
-              });
-            }
-          }
-        }
-        break;
       }
-      case "security": {
-        const securityConfig = parseSecurityConfig(config.security);
-        if (!securityConfig.enabled) break;
-        const scanner = new SecurityScanner(securityConfig);
-        scanner.configureForProject(projectRoot);
-        const { glob: globFn } = await import("glob");
-        const sourceFiles = await globFn("**/*.{ts,tsx,js,jsx,go,py}", {
-          cwd: projectRoot,
-          ignore: securityConfig.exclude ?? [
-            "**/node_modules/**",
-            "**/dist/**",
-            "**/*.test.ts",
-            "**/fixtures/**"
-          ],
-          absolute: true
+    }
+  }
+  return issues;
+}
+async function runSecurityCheck(projectRoot, config) {
+  const issues = [];
+  const securityConfig = parseSecurityConfig(config.security);
+  if (!securityConfig.enabled) return issues;
+  const scanner = new SecurityScanner(securityConfig);
+  scanner.configureForProject(projectRoot);
+  const { glob: globFn } = await import("glob");
+  const sourceFiles = await globFn("**/*.{ts,tsx,js,jsx,go,py}", {
+    cwd: projectRoot,
+    ignore: securityConfig.exclude ?? [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/*.test.ts",
+      "**/fixtures/**"
+    ],
+    absolute: true
+  });
+  const scanResult = await scanner.scanFiles(sourceFiles);
+  for (const finding of scanResult.findings) {
+    issues.push({
+      severity: finding.severity === "info" ? "warning" : finding.severity,
+      message: `[${finding.ruleId}] ${finding.message}: ${finding.match}`,
+      file: finding.file,
+      line: finding.line
+    });
+  }
+  return issues;
+}
+async function runPerfCheck(projectRoot, config) {
+  const issues = [];
+  const perfConfig = config.performance || {};
+  const perfAnalyzer = new EntropyAnalyzer({
+    rootDir: projectRoot,
+    analyze: {
+      complexity: perfConfig.complexity || true,
+      coupling: perfConfig.coupling || true,
+      sizeBudget: perfConfig.sizeBudget || false
+    }
+  });
+  const perfResult = await perfAnalyzer.analyze();
+  if (!perfResult.ok) {
+    issues.push({ severity: "warning", message: perfResult.error.message });
+  } else {
+    const perfReport = perfResult.value;
+    if (perfReport.complexity) {
+      for (const v of perfReport.complexity.violations) {
+        issues.push({
+          severity: v.severity === "info" ? "warning" : v.severity,
+          message: `[Tier ${v.tier}] ${v.metric}: ${v.function} in ${v.file} (${v.value} > ${v.threshold})`,
+          file: v.file,
+          line: v.line
         });
-        const scanResult = await scanner.scanFiles(sourceFiles);
-        for (const finding of scanResult.findings) {
-          issues.push({
-            severity: finding.severity === "info" ? "warning" : finding.severity,
-            message: `[${finding.ruleId}] ${finding.message}: ${finding.match}`,
-            file: finding.file,
-            line: finding.line
-          });
-        }
-        break;
       }
-      case "perf": {
-        const perfConfig = config.performance || {};
-        const perfAnalyzer = new EntropyAnalyzer({
-          rootDir: projectRoot,
-          analyze: {
-            complexity: perfConfig.complexity || true,
-            coupling: perfConfig.coupling || true,
-            sizeBudget: perfConfig.sizeBudget || false
-          }
+    }
+    if (perfReport.coupling) {
+      for (const v of perfReport.coupling.violations) {
+        issues.push({
+          severity: v.severity === "info" ? "warning" : v.severity,
+          message: `[Tier ${v.tier}] ${v.metric}: ${v.file} (${v.value} > ${v.threshold})`,
+          file: v.file
         });
-        const perfResult = await perfAnalyzer.analyze();
-        if (!perfResult.ok) {
-          issues.push({ severity: "warning", message: perfResult.error.message });
-        } else {
-          const perfReport = perfResult.value;
-          if (perfReport.complexity) {
-            for (const v of perfReport.complexity.violations) {
-              issues.push({
-                severity: v.severity === "info" ? "warning" : v.severity,
-                message: `[Tier ${v.tier}] ${v.metric}: ${v.function} in ${v.file} (${v.value} > ${v.threshold})`,
-                file: v.file,
-                line: v.line
-              });
-            }
-          }
-          if (perfReport.coupling) {
-            for (const v of perfReport.coupling.violations) {
-              issues.push({
-                severity: v.severity === "info" ? "warning" : v.severity,
-                message: `[Tier ${v.tier}] ${v.metric}: ${v.file} (${v.value} > ${v.threshold})`,
-                file: v.file
-              });
-            }
-          }
-        }
-        break;
       }
-      case "phase-gate": {
-        const phaseGates = config.phaseGates;
-        if (!phaseGates?.enabled) {
-          break;
-        }
+    }
+  }
+  return issues;
+}
+async function runPhaseGateCheck(_projectRoot, config) {
+  const issues = [];
+  const phaseGates = config.phaseGates;
+  if (!phaseGates?.enabled) {
+    return issues;
+  }
+  issues.push({
+    severity: "warning",
+    message: "Phase gate is enabled but requires CLI context. Run `harness check-phase-gate` separately for full validation."
+  });
+  return issues;
+}
+async function runArchCheck(projectRoot, config) {
+  const issues = [];
+  const rawArchConfig = config.architecture;
+  const archConfig = ArchConfigSchema.parse(rawArchConfig ?? {});
+  if (!archConfig.enabled) return issues;
+  const results = await runAll(archConfig, projectRoot);
+  const baselineManager = new ArchBaselineManager(projectRoot, archConfig.baselinePath);
+  const baseline = baselineManager.load();
+  if (baseline) {
+    const diffResult = diff(results, baseline);
+    if (!diffResult.passed) {
+      for (const v of diffResult.newViolations) {
         issues.push({
-          severity: "warning",
-          message: "Phase gate is enabled but requires CLI context. Run `harness check-phase-gate` separately for full validation."
+          severity: v.severity,
+          message: `[${v.category || "arch"}] NEW: ${v.detail}`,
+          file: v.file
         });
-        break;
       }
-      case "arch": {
-        const rawArchConfig = config.architecture;
-        const archConfig = ArchConfigSchema.parse(rawArchConfig ?? {});
-        if (!archConfig.enabled) break;
-        const results = await runAll(archConfig, projectRoot);
-        const baselineManager = new ArchBaselineManager(projectRoot, archConfig.baselinePath);
-        const baseline = baselineManager.load();
-        if (baseline) {
-          const diffResult = diff(results, baseline);
-          if (!diffResult.passed) {
-            for (const v of diffResult.newViolations) {
-              issues.push({
-                severity: v.severity,
-                message: `[${v.category || "arch"}] NEW: ${v.detail}`,
-                file: v.file
-              });
-            }
-            for (const r of diffResult.regressions) {
-              issues.push({
-                severity: "error",
-                message: `[${r.category}] REGRESSION: ${r.currentValue} > ${r.baselineValue} (delta: ${r.delta})`
-              });
-            }
-          }
-        } else {
-          for (const result of results) {
-            for (const v of result.violations) {
-              issues.push({
-                severity: v.severity,
-                message: `[${result.category}] ${v.detail}`,
-                file: v.file
-              });
-            }
-          }
-        }
-        break;
+      for (const r of diffResult.regressions) {
+        issues.push({
+          severity: "error",
+          message: `[${r.category}] REGRESSION: ${r.currentValue} > ${r.baselineValue} (delta: ${r.delta})`
+        });
+      }
+    }
+  } else {
+    for (const result of results) {
+      for (const v of result.violations) {
+        issues.push({
+          severity: v.severity,
+          message: `[${result.category}] ${v.detail}`,
+          file: v.file
+        });
       }
     }
+  }
+  return issues;
+}
+async function runSingleCheck(name, projectRoot, config) {
+  const start = Date.now();
+  const issues = [];
+  try {
+    switch (name) {
+      case "validate":
+        issues.push(...await runValidateCheck(projectRoot, config));
+        break;
+      case "deps":
+        issues.push(...await runDepsCheck(projectRoot, config));
+        break;
+      case "docs":
+        issues.push(...await runDocsCheck(projectRoot, config));
+        break;
+      case "entropy":
+        issues.push(...await runEntropyCheck(projectRoot, config));
+        break;
+      case "security":
+        issues.push(...await runSecurityCheck(projectRoot, config));
+        break;
+      case "perf":
+        issues.push(...await runPerfCheck(projectRoot, config));
+        break;
+      case "phase-gate":
+        issues.push(...await runPhaseGateCheck(projectRoot, config));
+        break;
+      case "arch":
+        issues.push(...await runArchCheck(projectRoot, config));
+        break;
+    }
   } catch (error) {
     issues.push({
       severity: "error",
@@ -7935,7 +8280,7 @@ async function runMechanicalChecks(options) {
   };
   if (!skip.includes("validate")) {
     try {
-      const agentsPath = path6.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
+      const agentsPath = path13.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
       const result = await validateAgentsMap(agentsPath);
       if (!result.ok) {
         statuses.validate = "fail";
@@ -7972,7 +8317,7 @@ async function runMechanicalChecks(options) {
       statuses.validate = "fail";
       findings.push({
         tool: "validate",
-        file: path6.join(projectRoot, "AGENTS.md"),
+        file: path13.join(projectRoot, "AGENTS.md"),
         message: err instanceof Error ? err.message : String(err),
         severity: "error"
       });
@@ -8036,7 +8381,7 @@ async function runMechanicalChecks(options) {
       (async () => {
         const localFindings = [];
         try {
-          const docsDir = path6.join(projectRoot, config.docsDir ?? "docs");
+          const docsDir = path13.join(projectRoot, config.docsDir ?? "docs");
           const result = await checkDocCoverage("project", { docsDir });
           if (!result.ok) {
             statuses["check-docs"] = "warn";
@@ -8063,7 +8408,7 @@ async function runMechanicalChecks(options) {
           statuses["check-docs"] = "warn";
           localFindings.push({
             tool: "check-docs",
-            file: path6.join(projectRoot, "docs"),
+            file: path13.join(projectRoot, "docs"),
             message: err instanceof Error ? err.message : String(err),
             severity: "warning"
           });
@@ -8212,18 +8557,18 @@ function computeContextBudget(diffLines) {
   return diffLines;
 }
 function isWithinProject(absPath, projectRoot) {
-  const resolvedRoot = path7.resolve(projectRoot) + path7.sep;
-  const resolvedPath = path7.resolve(absPath);
-  return resolvedPath.startsWith(resolvedRoot) || resolvedPath === path7.resolve(projectRoot);
+  const resolvedRoot = path14.resolve(projectRoot) + path14.sep;
+  const resolvedPath = path14.resolve(absPath);
+  return resolvedPath.startsWith(resolvedRoot) || resolvedPath === path14.resolve(projectRoot);
 }
 async function readContextFile(projectRoot, filePath, reason) {
-  const absPath = path7.isAbsolute(filePath) ? filePath : path7.join(projectRoot, filePath);
+  const absPath = path14.isAbsolute(filePath) ? filePath : path14.join(projectRoot, filePath);
   if (!isWithinProject(absPath, projectRoot)) return null;
   const result = await readFileContent(absPath);
   if (!result.ok) return null;
   const content = result.value;
   const lines = content.split("\n").length;
-  const relPath = path7.isAbsolute(filePath) ? path7.relative(projectRoot, filePath) : filePath;
+  const relPath = path14.isAbsolute(filePath) ? relativePosix(projectRoot, filePath) : filePath;
   return { path: relPath, content, reason, lines };
 }
 function extractImportSources2(content) {
@@ -8238,18 +8583,18 @@ function extractImportSources2(content) {
 }
 async function resolveImportPath2(projectRoot, fromFile, importSource) {
   if (!importSource.startsWith(".")) return null;
-  const fromDir = path7.dirname(path7.join(projectRoot, fromFile));
-  const basePath = path7.resolve(fromDir, importSource);
+  const fromDir = path14.dirname(path14.join(projectRoot, fromFile));
+  const basePath = path14.resolve(fromDir, importSource);
   if (!isWithinProject(basePath, projectRoot)) return null;
-  const relBase = path7.relative(projectRoot, basePath);
+  const relBase = relativePosix(projectRoot, basePath);
   const candidates = [
     relBase + ".ts",
     relBase + ".tsx",
     relBase + ".mts",
-    path7.join(relBase, "index.ts")
+    path14.join(relBase, "index.ts")
   ];
   for (const candidate of candidates) {
-    const absCandidate = path7.join(projectRoot, candidate);
+    const absCandidate = path14.join(projectRoot, candidate);
     if (await fileExists(absCandidate)) {
       return candidate;
     }
@@ -8257,10 +8602,10 @@ async function resolveImportPath2(projectRoot, fromFile, importSource) {
   return null;
 }
 async function findTestFiles(projectRoot, sourceFile) {
-  const baseName = path7.basename(sourceFile, path7.extname(sourceFile));
+  const baseName = path14.basename(sourceFile, path14.extname(sourceFile));
   const pattern = `**/${baseName}.{test,spec}.{ts,tsx,mts}`;
   const results = await findFiles(pattern, projectRoot);
-  return results.map((f) => path7.relative(projectRoot, f));
+  return results.map((f) => relativePosix(projectRoot, f));
 }
 async function gatherImportContext(projectRoot, changedFiles, budget) {
   const contextFiles = [];
@@ -9052,7 +9397,7 @@ function normalizePath(filePath, projectRoot) {
   let normalized = filePath;
   normalized = normalized.replace(/\\/g, "/");
   const normalizedRoot = projectRoot.replace(/\\/g, "/");
-  if (path8.isAbsolute(normalized)) {
+  if (path15.isAbsolute(normalized)) {
     const root = normalizedRoot.endsWith("/") ? normalizedRoot : normalizedRoot + "/";
     if (normalized.startsWith(root)) {
       normalized = normalized.slice(root.length);
@@ -9077,12 +9422,12 @@ function followImportChain(fromFile, fileContents, maxDepth = 2) {
     while ((match = importRegex.exec(content)) !== null) {
       const importPath = match[1];
       if (!importPath.startsWith(".")) continue;
-      const dir = path8.dirname(current.file);
-      let resolved = path8.join(dir, importPath).replace(/\\/g, "/");
+      const dir = path15.dirname(current.file);
+      let resolved = path15.join(dir, importPath).replace(/\\/g, "/");
       if (!resolved.match(/\.(ts|tsx|js|jsx)$/)) {
         resolved += ".ts";
       }
-      resolved = path8.normalize(resolved).replace(/\\/g, "/");
+      resolved = path15.normalize(resolved).replace(/\\/g, "/");
       if (!visited.has(resolved) && current.depth + 1 <= maxDepth) {
         queue.push({ file: resolved, depth: current.depth + 1 });
       }
@@ -9099,7 +9444,7 @@ async function validateFindings(options) {
     if (exclusionSet.isExcluded(normalizedFile, finding.lineRange) || exclusionSet.isExcluded(finding.file, finding.lineRange)) {
       continue;
     }
-    const absoluteFile = path8.isAbsolute(finding.file) ? finding.file : path8.join(projectRoot, finding.file).replace(/\\/g, "/");
+    const absoluteFile = path15.isAbsolute(finding.file) ? finding.file : path15.join(projectRoot, finding.file).replace(/\\/g, "/");
     if (exclusionSet.isExcluded(absoluteFile, finding.lineRange)) {
       continue;
     }
@@ -9603,6 +9948,8 @@ function parseFrontmatter(raw) {
   const versionStr = map.get("version");
   const lastSynced = map.get("last_synced");
   const lastManualEdit = map.get("last_manual_edit");
+  const created = map.get("created");
+  const updated = map.get("updated");
   if (!project || !versionStr || !lastSynced || !lastManualEdit) {
     return Err(
       new Error(
@@ -9614,7 +9961,10 @@ function parseFrontmatter(raw) {
   if (isNaN(version)) {
     return Err(new Error("Frontmatter version must be a number"));
   }
-  return Ok({ project, version, lastSynced, lastManualEdit });
+  const fm = { project, version, lastSynced, lastManualEdit };
+  if (created) fm.created = created;
+  if (updated) fm.updated = updated;
+  return Ok(fm);
 }
 function parseMilestones(body) {
   const milestones = [];
@@ -9622,12 +9972,12 @@ function parseMilestones(body) {
   const h2Matches = [];
   let match;
   while ((match = h2Pattern.exec(body)) !== null) {
-    h2Matches.push({ heading: match[1], startIndex: match.index });
+    h2Matches.push({ heading: match[1], startIndex: match.index, fullMatch: match[0] });
   }
   for (let i = 0; i < h2Matches.length; i++) {
     const h2 = h2Matches[i];
     const nextStart = i + 1 < h2Matches.length ? h2Matches[i + 1].startIndex : body.length;
-    const sectionBody = body.slice(h2.startIndex + h2.heading.length + 4, nextStart);
+    const sectionBody = body.slice(h2.startIndex + h2.fullMatch.length, nextStart);
     const isBacklog = h2.heading === "Backlog";
     const milestoneName = isBacklog ? "Backlog" : h2.heading.replace(/^Milestone:\s*/, "");
     const featuresResult = parseFeatures(sectionBody);
@@ -9642,19 +9992,16 @@ function parseMilestones(body) {
 }
 function parseFeatures(sectionBody) {
   const features = [];
-  const h3Pattern = /^### Feature: (.+)$/gm;
+  const h3Pattern = /^### (?:Feature: )?(.+)$/gm;
   const h3Matches = [];
   let match;
   while ((match = h3Pattern.exec(sectionBody)) !== null) {
-    h3Matches.push({ name: match[1], startIndex: match.index });
+    h3Matches.push({ name: match[1], startIndex: match.index, fullMatch: match[0] });
   }
   for (let i = 0; i < h3Matches.length; i++) {
     const h3 = h3Matches[i];
     const nextStart = i + 1 < h3Matches.length ? h3Matches[i + 1].startIndex : sectionBody.length;
-    const featureBody = sectionBody.slice(
-      h3.startIndex + `### Feature: ${h3.name}`.length,
-      nextStart
-    );
+    const featureBody = sectionBody.slice(h3.startIndex + h3.fullMatch.length, nextStart);
     const featureResult = parseFeatureFields(h3.name, featureBody);
     if (!featureResult.ok) return featureResult;
     features.push(featureResult.value);
@@ -9679,10 +10026,10 @@ function parseFeatureFields(name, body) {
   const status = statusRaw;
   const specRaw = fieldMap.get("Spec") ?? EM_DASH;
   const spec = specRaw === EM_DASH ? null : specRaw;
-  const plansRaw = fieldMap.get("Plans") ?? EM_DASH;
-  const plans = plansRaw === EM_DASH ? [] : plansRaw.split(",").map((p) => p.trim());
-  const blockedByRaw = fieldMap.get("Blocked by") ?? EM_DASH;
-  const blockedBy = blockedByRaw === EM_DASH ? [] : blockedByRaw.split(",").map((b) => b.trim());
+  const plansRaw = fieldMap.get("Plans") ?? fieldMap.get("Plan") ?? EM_DASH;
+  const plans = plansRaw === EM_DASH || plansRaw === "none" ? [] : plansRaw.split(",").map((p) => p.trim());
+  const blockedByRaw = fieldMap.get("Blocked by") ?? fieldMap.get("Blockers") ?? EM_DASH;
+  const blockedBy = blockedByRaw === EM_DASH || blockedByRaw === "none" ? [] : blockedByRaw.split(",").map((b) => b.trim());
   const summary = fieldMap.get("Summary") ?? "";
   return Ok({ name, status, spec, plans, blockedBy, summary });
 }
@@ -9692,11 +10039,17 @@ function serializeRoadmap(roadmap) {
   lines.push("---");
   lines.push(`project: ${roadmap.frontmatter.project}`);
   lines.push(`version: ${roadmap.frontmatter.version}`);
+  if (roadmap.frontmatter.created) {
+    lines.push(`created: ${roadmap.frontmatter.created}`);
+  }
+  if (roadmap.frontmatter.updated) {
+    lines.push(`updated: ${roadmap.frontmatter.updated}`);
+  }
   lines.push(`last_synced: ${roadmap.frontmatter.lastSynced}`);
   lines.push(`last_manual_edit: ${roadmap.frontmatter.lastManualEdit}`);
   lines.push("---");
   lines.push("");
-  lines.push("# Project Roadmap");
+  lines.push("# Roadmap");
   for (const milestone of roadmap.milestones) {
     lines.push("");
     lines.push(serializeMilestoneHeading(milestone));
@@ -9709,19 +10062,20 @@ function serializeRoadmap(roadmap) {
   return lines.join("\n");
 }
 function serializeMilestoneHeading(milestone) {
-  return milestone.isBacklog ? "## Backlog" : `## Milestone: ${milestone.name}`;
+  return milestone.isBacklog ? "## Backlog" : `## ${milestone.name}`;
 }
 function serializeFeature(feature) {
   const spec = feature.spec ?? EM_DASH2;
   const plans = feature.plans.length > 0 ? feature.plans.join(", ") : EM_DASH2;
   const blockedBy = feature.blockedBy.length > 0 ? feature.blockedBy.join(", ") : EM_DASH2;
   return [
-    `### Feature: ${feature.name}`,
+    `### ${feature.name}`,
+    "",
     `- **Status:** ${feature.status}`,
     `- **Spec:** ${spec}`,
-    `- **Plans:** ${plans}`,
-    `- **Blocked by:** ${blockedBy}`,
-    `- **Summary:** ${feature.summary}`
+    `- **Summary:** ${feature.summary}`,
+    `- **Blockers:** ${blockedBy}`,
+    `- **Plan:** ${plans}`
   ];
 }
 function inferStatus(feature, projectPath, allFeatures) {
@@ -9737,10 +10091,10 @@ function inferStatus(feature, projectPath, allFeatures) {
   const featuresWithPlans = allFeatures.filter((f) => f.plans.length > 0);
   const useRootState = featuresWithPlans.length <= 1;
   if (useRootState) {
-    const rootStatePath = path9.join(projectPath, ".harness", "state.json");
-    if (fs9.existsSync(rootStatePath)) {
+    const rootStatePath = path16.join(projectPath, ".harness", "state.json");
+    if (fs16.existsSync(rootStatePath)) {
       try {
-        const raw = fs9.readFileSync(rootStatePath, "utf-8");
+        const raw = fs16.readFileSync(rootStatePath, "utf-8");
         const state = JSON.parse(raw);
         if (state.progress) {
           for (const status of Object.values(state.progress)) {
@@ -9751,16 +10105,16 @@ function inferStatus(feature, projectPath, allFeatures) {
       }
     }
   }
-  const sessionsDir = path9.join(projectPath, ".harness", "sessions");
-  if (fs9.existsSync(sessionsDir)) {
+  const sessionsDir = path16.join(projectPath, ".harness", "sessions");
+  if (fs16.existsSync(sessionsDir)) {
     try {
-      const sessionDirs = fs9.readdirSync(sessionsDir, { withFileTypes: true });
+      const sessionDirs = fs16.readdirSync(sessionsDir, { withFileTypes: true });
       for (const entry of sessionDirs) {
         if (!entry.isDirectory()) continue;
-        const autopilotPath = path9.join(sessionsDir, entry.name, "autopilot-state.json");
-        if (!fs9.existsSync(autopilotPath)) continue;
+        const autopilotPath = path16.join(sessionsDir, entry.name, "autopilot-state.json");
+        if (!fs16.existsSync(autopilotPath)) continue;
         try {
-          const raw = fs9.readFileSync(autopilotPath, "utf-8");
+          const raw = fs16.readFileSync(autopilotPath, "utf-8");
           const autopilot = JSON.parse(raw);
           if (!autopilot.phases) continue;
           const linkedPhases = autopilot.phases.filter(
@@ -9840,10 +10194,10 @@ var ProjectScanner = class {
     this.rootDir = rootDir;
   }
   async scan() {
-    let projectName = path10.basename(this.rootDir);
+    let projectName = path17.basename(this.rootDir);
     try {
-      const pkgPath = path10.join(this.rootDir, "package.json");
-      const pkgRaw = await fs10.readFile(pkgPath, "utf-8");
+      const pkgPath = path17.join(this.rootDir, "package.json");
+      const pkgRaw = await fs17.readFile(pkgPath, "utf-8");
       const pkg = JSON.parse(pkgRaw);
       if (pkg.name) projectName = pkg.name;
     } catch {
@@ -9956,13 +10310,13 @@ var BlueprintGenerator = class {
       styles: STYLES,
       scripts: SCRIPTS
     });
-    await fs11.mkdir(options.outputDir, { recursive: true });
-    await fs11.writeFile(path11.join(options.outputDir, "index.html"), html);
+    await fs18.mkdir(options.outputDir, { recursive: true });
+    await fs18.writeFile(path18.join(options.outputDir, "index.html"), html);
   }
 };
 function getStatePath() {
   const home = process.env["HOME"] || os.homedir();
-  return path12.join(home, ".harness", "update-check.json");
+  return path19.join(home, ".harness", "update-check.json");
 }
 function isUpdateCheckEnabled(configInterval) {
   if (process.env["HARNESS_NO_UPDATE_CHECK"] === "1") return false;
@@ -9975,7 +10329,7 @@ function shouldRunCheck(state, intervalMs) {
 }
 function readCheckState() {
   try {
-    const raw = fs12.readFileSync(getStatePath(), "utf-8");
+    const raw = fs19.readFileSync(getStatePath(), "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && "lastCheckTime" in parsed && typeof parsed.lastCheckTime === "number" && "currentVersion" in parsed && typeof parsed.currentVersion === "string") {
       const state = parsed;
@@ -9992,7 +10346,7 @@ function readCheckState() {
 }
 function spawnBackgroundCheck(currentVersion) {
   const statePath = getStatePath();
-  const stateDir = path12.dirname(statePath);
+  const stateDir = path19.dirname(statePath);
   const script = `
 const { execSync } = require('child_process');
 const fs = require('fs');
@@ -10044,7 +10398,7 @@ function getUpdateNotification(currentVersion) {
   return `Update available: v${currentVersion} -> v${state.latestVersion}
 Run "harness update" to upgrade.`;
 }
-var VERSION = "0.11.0";
+var VERSION = "0.13.0";
 
 export {
   ArchMetricCategorySchema,
@@ -10182,16 +10536,28 @@ export {
   archiveStream,
   getStreamForBranch,
   migrateToStreams,
+  resolveSessionDir,
+  updateSessionIndex,
   loadState,
   saveState,
+  clearLearningsCache,
   appendLearning,
+  parseDateFromEntry,
+  analyzeLearningPatterns,
+  loadBudgetedLearnings,
   loadRelevantLearnings,
+  archiveLearnings,
+  pruneLearnings,
+  clearFailuresCache,
   appendFailure,
   loadFailures,
   archiveFailures,
   saveHandoff,
   loadHandoff,
   runMechanicalGate,
+  writeSessionSummary,
+  loadSessionSummary,
+  listActiveSessions,
   executeWorkflow,
   runPipeline,
   runMultiTurnPipeline,