@jaimevalasek/aioson 1.21.3 → 1.21.4

package/src/commands/context-health.js

@@ -21,21 +21,145 @@ function formatTokens(n) {
   return `~${n.toLocaleString()}`;
 }
 
-async function loadFeatureStatuses(contextDir) {
-  const featuresPath = path.join(contextDir, 'features.md');
-  try {
-    const content = await fs.readFile(featuresPath, 'utf8');
-    const done = new Set();
-    for (const line of content.split(/\r?\n/)) {
-      // Match lines like: - auth: done or | auth | done |
-      const m = line.match(/[-|]\s*([a-z0-9_-]+)\s*[:|]\s*done/i);
-      if (m) done.add(m[1].toLowerCase());
-    }
-    return done;
-  } catch {
-    return new Set();
-  }
-}
+async function loadFeatureStatuses(contextDir) {
+  const registry = await loadFeatureRegistry(contextDir);
+  return new Set(registry.done.map((feature) => feature.slug.toLowerCase()));
+}
+
+async function loadFeatureRegistry(contextDir) {
+  const featuresPath = path.join(contextDir, 'features.md');
+  try {
+    const content = await fs.readFile(featuresPath, 'utf8');
+    const features = [];
+    for (const line of content.split(/\r?\n/)) {
+      const table = line.match(/^\|\s*([a-z0-9_-]+)\s*\|\s*([a-z_ -]+)\s*\|/i);
+      if (table && table[1] !== 'slug') {
+        features.push({ slug: table[1].trim(), status: table[2].trim().toLowerCase() });
+        continue;
+      }
+
+      const list = line.match(/^-\s*([a-z0-9_-]+)\s*:\s*([a-z_ -]+)/i);
+      if (list) {
+        features.push({ slug: list[1].trim(), status: list[2].trim().toLowerCase() });
+      }
+    }
+    return {
+      all: features,
+      active: features.filter((feature) => feature.status === 'in_progress'),
+      done: features.filter((feature) => feature.status === 'done')
+    };
+  } catch {
+    return { all: [], active: [], done: [] };
+  }
+}
+
+function parseFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return {};
+
+  const result = {};
+  for (const line of match[1].split(/\r?\n/)) {
+    const idx = line.indexOf(':');
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim();
+    let value = line.slice(idx + 1).trim();
+    value = value.replace(/^["']|["']$/g, '');
+    result[key] = value;
+  }
+  return result;
+}
+
+async function readProjectClassification(contextDir) {
+  try {
+    const content = await fs.readFile(path.join(contextDir, 'project.context.md'), 'utf8');
+    return parseFrontmatter(content).classification || null;
+  } catch {
+    return null;
+  }
+}
+
+async function readWorkflowState(contextDir) {
+  try {
+    const raw = await fs.readFile(path.join(contextDir, 'workflow.state.json'), 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+async function readPulseActiveFeature(contextDir) {
+  try {
+    const content = await fs.readFile(path.join(contextDir, 'project-pulse.md'), 'utf8');
+    const frontmatter = parseFrontmatter(content);
+    return normalizePulseFeature(frontmatter.active_feature || null);
+  } catch {
+    return null;
+  }
+}
+
+function normalizePulseFeature(value) {
+  if (!value) return null;
+  const normalized = String(value).trim().replace(/^["']|["']$/g, '');
+  if (!normalized || ['none', 'project', '(none)', '-', '—'].includes(normalized.toLowerCase())) return null;
+  return normalized;
+}
+
+async function buildDriftWarnings(contextDir) {
+  const warnings = [];
+  const projectClassification = await readProjectClassification(contextDir);
+  const workflowState = await readWorkflowState(contextDir);
+  const featureRegistry = await loadFeatureRegistry(contextDir);
+  const pulseActiveFeature = await readPulseActiveFeature(contextDir);
+
+  if (
+    projectClassification &&
+    workflowState?.mode === 'feature' &&
+    workflowState.classification &&
+    projectClassification.toUpperCase() !== String(workflowState.classification).toUpperCase()
+  ) {
+    warnings.push({
+      id: 'classification_drift',
+      severity: 'warning',
+      message: `Project classification is ${projectClassification}; active workflow feature classification is ${workflowState.classification}.`,
+      suggested_command: 'aioson context:health . --json'
+    });
+  }
+
+  if (featureRegistry.active.length > 1) {
+    warnings.push({
+      id: 'multiple_active_features',
+      severity: 'warning',
+      message: `features.md has multiple in_progress features: ${featureRegistry.active.map((feature) => feature.slug).join(', ')}.`,
+      suggested_command: 'aioson feature:sweep . --dry-run'
+    });
+  }
+
+  const activeFeature = featureRegistry.active[0]?.slug || null;
+  if (activeFeature && pulseActiveFeature && activeFeature !== pulseActiveFeature) {
+    warnings.push({
+      id: 'active_state_drift',
+      severity: 'warning',
+      message: `features.md active feature is ${activeFeature}; project-pulse.md active_feature is ${pulseActiveFeature}.`,
+      suggested_command: 'aioson pulse:update . --feature=' + activeFeature
+    });
+  } else if (activeFeature && pulseActiveFeature === null) {
+    warnings.push({
+      id: 'active_state_drift',
+      severity: 'warning',
+      message: `features.md active feature is ${activeFeature}; project-pulse.md has no active_feature.`,
+      suggested_command: 'aioson pulse:update . --feature=' + activeFeature
+    });
+  } else if (!activeFeature && pulseActiveFeature) {
+    warnings.push({
+      id: 'active_state_drift',
+      severity: 'warning',
+      message: `project-pulse.md active_feature is ${pulseActiveFeature}, but features.md has no in_progress feature with that slug.`,
+      suggested_command: 'aioson pulse:update .'
+    });
+  }
+
+  return warnings;
+}
 
 async function getCacheHitRate(db) {
   if (!db) return null;
@@ -114,7 +238,7 @@ async function runContextHealth({ args, options = {}, logger }) {
 
   report.sort((a, b) => b.tokens - a.tokens);
 
-  const doneFeatures = await loadFeatureStatuses(contextDir);
+  const doneFeatures = await loadFeatureStatuses(contextDir);
   const staleSpecs = report.filter((r) => {
     if (!r.file.startsWith('spec-')) return false;
     const slug = r.file.replace(/^spec-/, '').replace(/\.md$/, '');
@@ -137,17 +261,19 @@ async function runContextHealth({ args, options = {}, logger }) {
     db.close();
   }
 
-  const skeletonPresent = entries.includes('skeleton-system.md') || entries.includes('skeleton.md');
-
-  if (options.json) {
-    return {
-      ok: true,
-      totalTokens,
-      files: report,
-      staleSpecs: staleSpecs.map((s) => s.file),
-      cacheHitRate,
-      skeletonPresent,
-      dbPath
+  const skeletonPresent = entries.includes('skeleton-system.md') || entries.includes('skeleton.md');
+  const driftWarnings = await buildDriftWarnings(contextDir);
+
+  if (options.json) {
+    return {
+      ok: true,
+      totalTokens,
+      files: report,
+      staleSpecs: staleSpecs.map((s) => s.file),
+      driftWarnings,
+      cacheHitRate,
+      skeletonPresent,
+      dbPath
     };
   }
 
@@ -189,7 +315,7 @@ async function runContextHealth({ args, options = {}, logger }) {
     logger.log('');
   }
 
-  if (staleSpecs.length > 0) {
+  if (staleSpecs.length > 0) {
     logger.log(`⚠  ${staleSpecs.length} stale spec file(s) (features: done):`);
     for (const s of staleSpecs) {
       const slug = s.file.replace(/^spec-/, '').replace(/\.md$/, '');
@@ -197,7 +323,16 @@ async function runContextHealth({ args, options = {}, logger }) {
     }
     logger.log(`   Run: aioson feature:archive . --feature=<slug> to archive them`);
     logger.log('');
-  }
+  }
+
+  if (driftWarnings.length > 0) {
+    logger.log(`⚠  ${driftWarnings.length} context drift warning(s):`);
+    for (const warning of driftWarnings) {
+      logger.log(`   → ${warning.message}`);
+      if (warning.suggested_command) logger.log(`     ${warning.suggested_command}`);
+    }
+    logger.log('');
+  }
 
   if (cacheHitRate !== null) {
     logger.log(`✓  Cache hit rate: ${cacheHitRate}% (last 7 days)`);
@@ -208,11 +343,12 @@ async function runContextHealth({ args, options = {}, logger }) {
 
   return {
     ok: true,
-    totalTokens,
-    files: report,
-    staleSpecs: staleSpecs.map((s) => s.file),
-    cacheHitRate,
-    skeletonPresent,
+    totalTokens,
+    files: report,
+    staleSpecs: staleSpecs.map((s) => s.file),
+    driftWarnings,
+    cacheHitRate,
+    skeletonPresent,
     dbPath
   };
 }

package/src/commands/devlog-process.js

@@ -50,11 +50,20 @@ function extractTaggedLearnings(content) {
   for (const line of section.split(/\r?\n/)) {
     const trimmed = line.replace(/^[-*]\s*/, '').trim();
     if (!trimmed) continue;
-    const typeMatch = trimmed.match(/^\[(process|domain|quality|preference)\]\s+(.+)/i);
+    const typeMatch = trimmed.match(/^\[(process|domain|quality|preference|gotcha|resolution)\]\s+(.+)/i);
     if (typeMatch) {
-      learnings.push({ type: typeMatch[1].toLowerCase(), title: typeMatch[2].trim() });
+      const tag = typeMatch[1].toLowerCase();
+      const title = typeMatch[2].trim();
+      // cross-tool-project-knowledge: gotcha/resolution are project-knowledge
+      // signals — persisted under type='quality' with the real signal in `kind`
+      // (project_learnings.type CHECK only allows the 4 base types).
+      if (tag === 'gotcha' || tag === 'resolution') {
+        learnings.push({ type: 'quality', kind: tag, title });
+      } else {
+        learnings.push({ type: tag, kind: null, title });
+      }
     } else if (trimmed.length > 5) {
-      learnings.push({ type: 'process', title: trimmed });
+      learnings.push({ type: 'process', kind: null, title: trimmed });
     }
   }
   return learnings;
@@ -69,25 +78,38 @@ function extractSummary(content) {
   return firstHeading ? firstHeading[1].trim() : null;
 }
 
-function upsertProjectLearning(db, { title, type, featureSlug, evidence, sourceSession }) {
+// cross-tool-project-knowledge: app-level allow-list for project_learnings.kind.
+// The column carries no schema CHECK by repo convention (see
+// learning-loop-migration.js Phase 4). NULL = not a project-knowledge learning.
+const ALLOWED_LEARNING_KINDS = new Set(['gotcha', 'resolution']);
+
+function normalizeKind(kind) {
+  return ALLOWED_LEARNING_KINDS.has(kind) ? kind : null;
+}
+
+function upsertProjectLearning(db, { title, type, kind, featureSlug, evidence, sourceSession }) {
+  const safeKind = normalizeKind(kind);
   const existing = db.prepare(
-    'SELECT learning_id, frequency FROM project_learnings WHERE title = ? AND (feature_slug = ? OR (feature_slug IS NULL AND ? IS NULL))'
+    'SELECT learning_id, frequency, kind FROM project_learnings WHERE title = ? AND (feature_slug = ? OR (feature_slug IS NULL AND ? IS NULL))'
   ).get(title, featureSlug || null, featureSlug || null);
 
   if (existing) {
+    // Enrich kind only when previously unset — a plain re-tag must not clobber
+    // an existing classification.
+    const nextKind = existing.kind || safeKind || null;
     db.prepare(
-      'UPDATE project_learnings SET frequency = ?, last_reinforced = ?, updated_at = ? WHERE learning_id = ?'
-    ).run(existing.frequency + 1, nowIso(), nowIso(), existing.learning_id);
+      'UPDATE project_learnings SET frequency = ?, last_reinforced = ?, updated_at = ?, kind = ? WHERE learning_id = ?'
+    ).run(existing.frequency + 1, nowIso(), nowIso(), nextKind, existing.learning_id);
     return { action: 'updated', learningId: existing.learning_id };
   }
 
   const learningId = createLearningId();
   db.prepare(`
     INSERT INTO project_learnings
-      (learning_id, feature_slug, type, title, confidence, frequency, last_reinforced,
+      (learning_id, feature_slug, type, kind, title, confidence, frequency, last_reinforced,
        applies_to, source_session, evidence, status, created_at, updated_at)
-    VALUES (?, ?, ?, ?, 'medium', 1, ?, 'project', ?, ?, 'active', ?, ?)
-  `).run(learningId, featureSlug || null, type, title, nowIso(), sourceSession || null, evidence || null, nowIso(), nowIso());
+    VALUES (?, ?, ?, ?, ?, 'medium', 1, ?, 'project', ?, ?, 'active', ?, ?)
+  `).run(learningId, featureSlug || null, type, safeKind, title, nowIso(), sourceSession || null, evidence || null, nowIso(), nowIso());
   return { action: 'inserted', learningId };
 }
 
@@ -168,8 +190,8 @@ async function processDevlogFile(db, filePath) {
 
   // Upsert learnings
   const learnings = extractTaggedLearnings(body);
-  for (const { type, title } of learnings) {
-    upsertProjectLearning(db, { title, type, featureSlug, sourceSession: sessionKey || path.basename(filePath) });
+  for (const { type, title, kind } of learnings) {
+    upsertProjectLearning(db, { title, type, kind, featureSlug, sourceSession: sessionKey || path.basename(filePath) });
   }
 
   // Log verdict if present
@@ -291,4 +313,4 @@ async function runDevlogProcess({ args, options = {}, logger }) {
   return { ok: true, results, processed: processed.length, skipped: skipped.length, malformed: malformed.length, totalArtifacts, totalLearnings, dbPath };
 }
 
-module.exports = { runDevlogProcess, processDevlogFile };
+module.exports = { runDevlogProcess, processDevlogFile, extractTaggedLearnings, upsertProjectLearning };

package/src/commands/learning.js

@@ -1,13 +1,19 @@
 'use strict';
 
-const path = require('node:path');
-const {
-  openRuntimeDb,
-  listProjectLearnings,
+const path = require('node:path');
+const {
+  openRuntimeDb,
+  listProjectLearnings,
   getProjectLearning,
-  promoteProjectLearning,
-  getProjectLearningStats
-} = require('../runtime-store');
+  promoteProjectLearning,
+  getProjectLearningStats
+} = require('../runtime-store');
+const {
+  loadClaudeMemoryCandidates,
+  parseSelection,
+  isSelected
+} = require('../learning-import-claude');
+const { upsertProjectLearning } = require('./devlog-process');
 
 /**
  * Subcommand: list [--status=active|stale|archived|promoted]
@@ -78,7 +84,7 @@ async function handleStats(projectDir, { logger, t }) {
  * Subcommand: promote <learning-id> --to=<rule-path>
  * Promotes a learning to a project rule.
  */
-async function handlePromote(projectDir, learningId, promotedTo, { logger, t }) {
+async function handlePromote(projectDir, learningId, promotedTo, { logger, t }) {
   if (!learningId) {
     logger.error(t('learning.promote_usage'));
     return { promoted: false };
@@ -106,7 +112,77 @@ async function handlePromote(projectDir, learningId, promotedTo, { logger, t })
   } finally {
     db.close();
   }
-}
+}
+
+/**
+ * Subcommand: import-from-claude [--project-hash=<hash>] [--dry-run] [--select=1,2|all]
+ * Imports technical Claude Code project memory into project_learnings.
+ */
+async function handleImportFromClaude(projectDir, options, { logger }) {
+  let loaded;
+  try {
+    loaded = await loadClaudeMemoryCandidates({
+      targetDir: projectDir,
+      projectHash: options['project-hash'] || options.projectHash,
+      claudeHome: options['claude-home'] || options.claudeHome
+    });
+  } catch (err) {
+    logger.error(err.message);
+    return { ok: false, error: err.code || 'import_failed', candidates: [], promoted: 0 };
+  }
+
+  const selection = parseSelection(options.select);
+  const dryRun = Boolean(options['dry-run'] || options.dryRun);
+  const candidates = loaded.candidates;
+
+  logger.log(`Claude memory candidates (${candidates.length}) — ${loaded.hash}`);
+  for (const candidate of candidates) {
+    const marker = candidate.kind ? candidate.kind : candidate.classification;
+    logger.log(`  [${candidate.index}] ${marker}: ${candidate.title} (${candidate.source})`);
+  }
+
+  if (dryRun || !selection) {
+    if (!selection) logger.log('Run again with --select=<n[,n]|all> to import technical candidates.');
+    return {
+      ok: true,
+      dryRun: true,
+      requiresSelection: !selection,
+      projectHash: loaded.hash,
+      candidates,
+      promoted: 0,
+      skipped: 0
+    };
+  }
+
+  const handle = await openRuntimeDb(projectDir);
+  const { db } = handle;
+  const promoted = [];
+  const skipped = [];
+  try {
+    for (const candidate of candidates) {
+      if (!isSelected(selection, candidate.index)) continue;
+      if (!candidate.kind) {
+        skipped.push({ index: candidate.index, title: candidate.title, reason: candidate.classification });
+        continue;
+      }
+      const result = upsertProjectLearning(db, {
+        title: candidate.title,
+        type: 'quality',
+        kind: candidate.kind,
+        featureSlug: options.feature || null,
+        evidence: candidate.evidence,
+        sourceSession: `claude-memory:${loaded.hash}:${candidate.source}`
+      });
+      promoted.push({ ...result, index: candidate.index, title: candidate.title, kind: candidate.kind });
+    }
+  } finally {
+    db.close();
+  }
+
+  logger.log(`Imported: ${promoted.length}`);
+  if (skipped.length > 0) logger.log(`Skipped: ${skipped.length}`);
+  return { ok: true, dryRun: false, projectHash: loaded.hash, candidates, promoted, skipped };
+}
 
 /**
  * Entry point for CLI integration.
@@ -122,13 +198,16 @@ async function runLearning({ args = [], options = {}, logger = console, t = (k)
   if (sub === 'stats') {
     return handleStats(projectDir, context);
   }
-  if (sub === 'promote') {
-    const learningId = args[2] || options.id;
-    return handlePromote(projectDir, learningId, options.to || null, context);
-  }
-
-  logger.error(`Unknown subcommand: ${sub}. Available: list, stats, promote`);
-  return { error: true };
-}
-
-module.exports = { runLearning, handleList, handleStats, handlePromote };
+  if (sub === 'promote') {
+    const learningId = args[2] || options.id;
+    return handlePromote(projectDir, learningId, options.to || null, context);
+  }
+  if (sub === 'import-from-claude') {
+    return handleImportFromClaude(projectDir, options, context);
+  }
+
+  logger.error(`Unknown subcommand: ${sub}. Available: list, stats, promote, import-from-claude`);
+  return { error: true };
+}
+
+module.exports = { runLearning, handleList, handleStats, handlePromote, handleImportFromClaude };

package/src/commands/live.js

@@ -19,7 +19,7 @@ const {
 const { ensureDir, exists } = require('../utils');
 const { SUPPORTED_PROMPT_TOOLS } = require('../prompt-tool');
 const { isTmuxAvailable, launchTmuxSession, buildSessionName, hasSession, attachSession } = require('../lib/tmux-launcher');
-const { resolvePermissionModeArgs, resolveResumeArgs } = require('../lib/tool-capabilities');
+const { resolvePermissionModeArgs, resolveResumeArgs } = require('../lib/tool-capabilities');
 
 const LIVE_EVENTS_LIMIT = 10;
 const LIVE_MESSAGE_LIMIT = 500;
@@ -116,16 +116,16 @@ function parseJsonOption(value) {
   }
 }
 
-// Combine `--resume` (mapped per-tool via TOOL_CAPS) with user-provided `--tool-args`.
-// Resume args go FIRST so that codex `resume --last` (subcommand) lands at argv[1].
-function buildLaunchArgs(options, tool) {
-  const resumeOpt = options.resume !== undefined ? options.resume : options.Resume;
-  const resumeArgs = resolveResumeArgs(tool, resumeOpt);
-  const permissionMode = options['permission-mode'] || options.permissionMode;
-  const permissionArgs = resolvePermissionModeArgs(tool, permissionMode);
-  const userArgs = parseToolArgs(options['tool-args'] || options.toolArgs);
-  return [...resumeArgs, ...permissionArgs, ...userArgs];
-}
+// Combine `--resume` (mapped per-tool via TOOL_CAPS) with user-provided `--tool-args`.
+// Resume args go FIRST so that codex `resume --last` (subcommand) lands at argv[1].
+function buildLaunchArgs(options, tool) {
+  const resumeOpt = options.resume !== undefined ? options.resume : options.Resume;
+  const resumeArgs = resolveResumeArgs(tool, resumeOpt);
+  const permissionMode = options['permission-mode'] || options.permissionMode;
+  const permissionArgs = resolvePermissionModeArgs(tool, permissionMode);
+  const userArgs = parseToolArgs(options['tool-args'] || options.toolArgs);
+  return [...resumeArgs, ...permissionArgs, ...userArgs];
+}
 
 function parseToolArgs(value) {
   if (value === undefined || value === null || value === '') return [];
@@ -253,6 +253,15 @@ async function resolveExecutablePath(command) {
   return null;
 }
 
+// Com `shell: true` (Windows), o comando vai pro cmd.exe. Um caminho com espaços
+// — ex.: "C:\Program Files\nodejs\codex.cmd" — quebra se não for quotado (o
+// cmd.exe corta no primeiro espaço e tenta rodar "C:\Program"). Quotamos o
+// executável; sem shell (Unix) ele vai cru. Resolve o ENOENT/falha ao iniciar
+// codex/claude no Windows quando o npm bin fica no Program Files.
+function spawnExecutable(binaryPath) {
+  return process.platform === 'win32' ? `"${binaryPath}"` : binaryPath;
+}
+
 function detectProcessState(pid) {
   if (!pid) return 'not_tracked';
   try {
@@ -1135,7 +1144,12 @@ async function getLiveStatusSnapshot(targetDir, t, options = {}) {
 
 async function runLiveStart({ args, options = {}, logger, t }) {
   const targetDir = resolveTargetDir(args);
-  const agentName = normalizeAgentHandle(requireOption(options, 'agent', t));
+  // --agent é OPCIONAL: serve só pra tagueamento/tracking da sessão (session
+  // key, run, runtime emit). live:start NÃO invoca/injeta o agente — isso é
+  // feito DENTRO do harness (o usuário roda /product etc. na própria CLI). Por
+  // isso o caller (ex.: o Play) não precisa forçar um agente. Default 'product'
+  // quando omitido, mantendo o tracking consistente sem exigir a flag.
+  const agentName = normalizeAgentHandle(options.agent || 'product');
   const tool = normalizeLiveTool(requireOption(options, 'tool', t), t);
   const noLaunch = Boolean(options['no-launch']);
 
@@ -1239,27 +1253,39 @@ async function runLiveStart({ args, options = {}, logger, t }) {
       } else {
         // Non-tmux reuse logic
         const existingTool = state.tool_session || null;
-        if (existingTool && existingTool !== tool) {
-          // Auto-close stale session when tool changed (same pattern as tmux recovery above)
+        // Reconcilia sessão órfã: se o processo da sessão "ativa" já morreu
+        // (Play/terminal fechado sem close limpo, ou o tool crashou DEPOIS de
+        // gravar o registro), NÃO reusar — senão o start novo só loga "session
+        // already active", o tool nunca sobe e a órfã trava todo restart. Morto
+        // é tratado igual a troca de tool: auto-close + cria sessão nova abaixo.
+        const existingProcessDead = detectProcessState(state.child_pid) === 'dead';
+        const toolChanged = Boolean(existingTool && existingTool !== tool);
+        if (toolChanged || existingProcessDead) {
+          const closeReason = toolChanged
+            ? `tool changed from ${existingTool} to ${tool}`
+            : 'previous process is no longer running';
           updateRun(db, {
             runKey: existing.run.run_key,
             status: 'completed',
-            summary: `Auto-closed: tool changed from ${existingTool} to ${tool}`,
+            summary: `Auto-closed: ${closeReason}`,
             eventType: 'session_closed',
             phase: 'live',
-            message: `Tool mismatch — auto-closed previous ${existingTool} session`
+            message: `Auto-closed previous session — ${closeReason}`
           });
           if (existing.task?.task_key) {
             updateTask(db, {
               taskKey: existing.task.task_key,
               status: 'completed',
-              goal: `Auto-closed after tool change to ${tool}`
+              goal: `Auto-closed (${closeReason})`
             });
           }
           await clearAgentSession(runtimeDir, agentName);
           if (!options.json) {
-            logger.log(t('live.tool_mismatch_auto_closed', { existing: existingTool, requested: tool }) ||
-              `Previous session (${existingTool}) auto-closed — starting new with ${tool}`);
+            const msg = toolChanged
+              ? (t('live.tool_mismatch_auto_closed', { existing: existingTool, requested: tool }) ||
+                 `Previous session (${existingTool}) auto-closed — starting new with ${tool}`)
+              : `Previous ${tool} session was dead — auto-closed, starting fresh`;
+            logger.log(msg);
           }
           // Fall through to create a new session below
         } else {
@@ -1269,7 +1295,7 @@ async function runLiveStart({ args, options = {}, logger, t }) {
           let attachResult = null;
 
           if (attach && !noLaunch) {
-            attachChild = spawn(binaryPath, buildLaunchArgs(options, tool), {
+            attachChild = spawn(spawnExecutable(binaryPath), buildLaunchArgs(options, tool), {
               cwd: targetDir,
               env: process.env,
               stdio: 'inherit',
@@ -1378,7 +1404,7 @@ async function runLiveStart({ args, options = {}, logger, t }) {
           });
         } else {
           // Fallback to normal spawn if tmux not available
-          child = spawn(binaryPath, buildLaunchArgs(options, tool), {
+          child = spawn(spawnExecutable(binaryPath), buildLaunchArgs(options, tool), {
             cwd: targetDir,
             env: process.env,
             stdio: 'inherit',
@@ -1391,7 +1417,7 @@ async function runLiveStart({ args, options = {}, logger, t }) {
           });
         }
       } else {
-        child = spawn(binaryPath, buildLaunchArgs(options, tool), {
+        child = spawn(spawnExecutable(binaryPath), buildLaunchArgs(options, tool), {
           cwd: targetDir,
           env: process.env,
           stdio: 'inherit',

package/src/commands/preflight.js

@@ -77,9 +77,14 @@ async function runPreflight({ args, options = {}, logger }) {
     : null;
 
   // Determine mode
-  const mode = slug
-    ? (artifacts.prd.exists ? 'feature' : 'continuation')
-    : (artifacts.project_context.exists ? 'project' : 'greenfield');
+  const hasFeatureArtifacts = artifacts.prd.exists
+    || artifacts.requirements.exists
+    || artifacts.spec.exists
+    || artifacts.implementation_plan.exists
+    || (manifest && manifest.exists);
+  const mode = slug
+    ? (artifacts.prd.exists ? 'feature' : (hasFeatureArtifacts ? 'continuation' : 'unframed_feature'))
+    : (artifacts.project_context.exists ? 'project' : 'greenfield');
 
   // Spec version + checkpoint
   const specVersion = extractSpecVersion(artifacts.spec);
@@ -104,8 +109,10 @@ async function runPreflight({ args, options = {}, logger }) {
         version: specVersion,
         last_checkpoint: lastCheckpoint
       },
-      architecture: { exists: artifacts.architecture.exists },
-      implementation_plan: {
+      architecture: { exists: artifacts.architecture.exists },
+      design_doc: { exists: artifacts.design_doc.exists, path: artifacts.design_doc.path || null },
+      readiness: { exists: artifacts.readiness.exists, path: artifacts.readiness.path || null },
+      implementation_plan: {
         exists: artifacts.implementation_plan.exists,
         path: artifacts.implementation_plan.path || null,
         status: artifacts.implementation_plan.exists ? (artifacts.implementation_plan.frontmatter.status || null) : null
@@ -179,8 +186,10 @@ async function runPreflight({ args, options = {}, logger }) {
     slug
       ? [`spec-${slug}.md`, artifacts.spec.exists, specVersion ? `version: ${specVersion}${lastCheckpoint ? ', last: "' + lastCheckpoint + '"' : ''}` : null]
       : null,
-    ['architecture.md', artifacts.architecture.exists, null],
-    slug ? [`implementation-plan-${slug}.md`, artifacts.implementation_plan.exists, artifacts.implementation_plan.exists ? `status: ${artifacts.implementation_plan.frontmatter.status || 'unknown'}` : null] : null,
+    ['architecture.md', artifacts.architecture.exists, null],
+    ['design-doc.md', artifacts.design_doc.exists, classification === 'MICRO' ? 'SMALL/MEDIUM pre-dev only' : null],
+    ['readiness.md', artifacts.readiness.exists, classification === 'MICRO' ? 'SMALL/MEDIUM pre-dev only' : null],
+    slug ? [`implementation-plan-${slug}.md`, artifacts.implementation_plan.exists, artifacts.implementation_plan.exists ? `status: ${artifacts.implementation_plan.frontmatter.status || 'unknown'}` : null] : null,
     slug ? [`conformance-${slug}.yaml`, artifacts.conformance.exists, classification === 'SMALL' || classification === 'MICRO' ? 'MEDIUM only — not required' : null] : null
   ].filter(Boolean);