create-walle 0.9.21 → 0.9.23

package/template/claude-task-manager/lib/skill-autocomplete.js

@@ -146,6 +146,14 @@ function loadSkill(skillDir, source) {
     execution: parsed.meta.execution || '',
     source,
     agents: declaredAgents.length ? declaredAgents : skillCompatibleAgentsForSource(source),
+    capabilities: normalizeSkillCapabilities(
+      parsed.meta.capabilities ||
+      parsed.meta.capability ||
+      parsed.meta.skills_capabilities ||
+      parsed.meta.skill_capabilities
+    ),
+    intents: normalizeSkillCapabilities(parsed.meta.intents || parsed.meta.intent),
+    invocation: normalizeSkillInvocation(parsed.meta.invocation || parsed.meta.command_prefix || parsed.meta.prefix),
     filePath: skillMdPath,
     path: skillMdPath,
   };
@@ -170,7 +178,24 @@ function parseFrontmatter(text) {
     if (!line || line.startsWith('#')) continue;
     const match = line.match(/^([A-Za-z0-9_.-]+):\s*(.*)$/);
     if (!match) continue;
-    const blockStyle = match[2].match(/^([>|])[-+]?$/);
+    const valueText = String(match[2] || '').trim();
+    if (!valueText) {
+      const list = [];
+      let j = i + 1;
+      for (; j < lines.length; j += 1) {
+        const next = lines[j];
+        if (!next.trim()) continue;
+        const itemMatch = next.match(/^\s*-\s*(.+)$/);
+        if (!itemMatch) break;
+        list.push(parseFrontmatterValue(itemMatch[1]));
+      }
+      if (list.length) {
+        meta[match[1]] = list.flat ? list.flat(Infinity) : list;
+        i = j - 1;
+        continue;
+      }
+    }
+    const blockStyle = valueText.match(/^([>|])[-+]?$/);
     if (blockStyle) {
       const block = [];
       let j = i + 1;
@@ -219,6 +244,38 @@ function normalizeSkillAgents(value) {
   return out;
 }
 
+function normalizeSkillCapabilities(value) {
+  if (!value) return [];
+  const raw = Array.isArray(value)
+    ? value
+    : typeof value === 'string'
+      ? value.split(/[,\s]+/)
+      : [value];
+  const out = [];
+  const seen = new Set();
+  for (const item of raw.flat ? raw.flat(Infinity) : raw) {
+    const normalized = String(item || '')
+      .trim()
+      .toLowerCase()
+      .replace(/_/g, '.')
+      .replace(/:+/g, '.')
+      .replace(/[^a-z0-9.-]+/g, '.')
+      .replace(/^\.+|\.+$/g, '');
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    out.push(normalized);
+  }
+  return out;
+}
+
+function normalizeSkillInvocation(value) {
+  const text = String(value || '').trim();
+  if (text === '$' || text === '/') return text;
+  if (/^dollar$/i.test(text)) return '$';
+  if (/^slash$/i.test(text)) return '/';
+  return '';
+}
+
 function skillCompatibleAgentsForSource(source) {
   const s = String(source || '').toLowerCase();
   if (s.startsWith('agents-')) return ['claude', 'codex', 'gemini', 'opencode', 'walle'];
@@ -260,6 +317,123 @@ function skillSourcePriorityForAgent(source, agentType) {
   return 20;
 }
 
+function normalizeSkillAutocompleteQuery(value) {
+  const text = String(value || '').trim().replace(/^[$/]+/, '').toLowerCase();
+  return text.replace(/[^a-z0-9_.:-]/g, '');
+}
+
+function skillAutocompleteMatch(name, query) {
+  const q = normalizeSkillAutocompleteQuery(query);
+  const n = normalizeSkillAutocompleteQuery(name);
+  if (!n) return null;
+  if (!q) return {
+    tier: 100,
+    index: 0,
+    gap: 0,
+    lengthDelta: n.length,
+  };
+
+  const qCompact = q.replace(/[_.:-]+/g, '');
+  const nCompact = n.replace(/[_.:-]+/g, '');
+
+  if (n === q) return { tier: 0, index: 0, gap: 0, lengthDelta: 0 };
+  if (n.startsWith(q)) return { tier: 1, index: 0, gap: 0, lengthDelta: n.length - q.length };
+
+  const segments = n.split(/[_.:-]+/).filter(Boolean);
+  let bestSegmentDelta = Infinity;
+  for (const segment of segments) {
+    if (segment.startsWith(q)) bestSegmentDelta = Math.min(bestSegmentDelta, segment.length - q.length);
+  }
+  if (Number.isFinite(bestSegmentDelta)) {
+    return { tier: 2, index: 0, gap: 0, lengthDelta: bestSegmentDelta };
+  }
+
+  if (qCompact && nCompact === qCompact) return { tier: 3, index: 0, gap: 0, lengthDelta: 0 };
+  if (qCompact && nCompact.startsWith(qCompact)) {
+    return { tier: 4, index: 0, gap: 0, lengthDelta: nCompact.length - qCompact.length };
+  }
+
+  const index = n.indexOf(q);
+  if (index >= 0) {
+    return { tier: 5, index, gap: 0, lengthDelta: n.length - q.length };
+  }
+
+  const fuzzy = fuzzySubsequenceMatch(n, q);
+  if (fuzzy) {
+    return {
+      tier: 8,
+      index: fuzzy.firstIndex,
+      gap: fuzzy.gap,
+      lengthDelta: n.length - q.length,
+    };
+  }
+
+  return null;
+}
+
+function fuzzySubsequenceMatch(name, query) {
+  if (!query) return { firstIndex: 0, gap: 0 };
+  let qi = 0;
+  let firstIndex = -1;
+  let previousIndex = -1;
+  let gap = 0;
+  for (let i = 0; i < name.length && qi < query.length; i += 1) {
+    if (name[i] !== query[qi]) continue;
+    if (firstIndex < 0) firstIndex = i;
+    if (previousIndex >= 0) gap += i - previousIndex - 1;
+    previousIndex = i;
+    qi += 1;
+  }
+  return qi === query.length ? { firstIndex: Math.max(0, firstIndex), gap } : null;
+}
+
+function filterAndSortSkillAutocompleteItems(items, query, agentType) {
+  const q = normalizeSkillAutocompleteQuery(query);
+  const agent = normalizeSkillAgentType(agentType);
+  const matches = [];
+  for (const item of safeArray(items)) {
+    const match = skillAutocompleteMatch(item?.name, q);
+    if (!match) continue;
+    matches.push({ item, match });
+  }
+
+  matches.sort((a, b) => compareSkillAutocompleteMatches(a, b, q, agent));
+  return matches.map((entry) => entry.item);
+}
+
+function compareSkillAutocompleteMatches(a, b, query, agentType) {
+  const aMatch = a?.match || {};
+  const bMatch = b?.match || {};
+  if (query) {
+    if (aMatch.tier !== bMatch.tier) return aMatch.tier - bMatch.tier;
+    if (aMatch.index !== bMatch.index) return aMatch.index - bMatch.index;
+    if (aMatch.gap !== bMatch.gap) return aMatch.gap - bMatch.gap;
+    if (aMatch.lengthDelta !== bMatch.lengthDelta) return aMatch.lengthDelta - bMatch.lengthDelta;
+    const nameLengthDelta = normalizeSkillAutocompleteQuery(a?.item?.name).length -
+      normalizeSkillAutocompleteQuery(b?.item?.name).length;
+    if (nameLengthDelta) return nameLengthDelta;
+  } else {
+    const aFreq = Number(a?.item?.frequency || 0);
+    const bFreq = Number(b?.item?.frequency || 0);
+    if (bFreq !== aFreq) return bFreq - aFreq;
+  }
+
+  const sourceDelta = skillSourcePriorityForAgent(a?.item?.source, agentType) -
+    skillSourcePriorityForAgent(b?.item?.source, agentType);
+  if (sourceDelta) return sourceDelta;
+
+  if (query) {
+    const aFreq = Number(a?.item?.frequency || 0);
+    const bFreq = Number(b?.item?.frequency || 0);
+    if (bFreq !== aFreq) return bFreq - aFreq;
+  }
+
+  return String(a?.item?.name || '').localeCompare(String(b?.item?.name || ''), undefined, {
+    numeric: true,
+    sensitivity: 'base',
+  });
+}
+
 function normalizeSkillName(value) {
   const name = String(value || '').trim().replace(/^@skill\//, '').replace(/\s+/g, '-');
   return /^[A-Za-z0-9_.:-]{1,80}$/.test(name) ? name : '';
@@ -290,9 +464,14 @@ function reloadSkills() {
 }
 
 module.exports = {
+  filterAndSortSkillAutocompleteItems,
   filterSkillsForAgent,
+  isSkillCompatibleWithAgent,
   loadAllSkillEntries,
   normalizeSkillAgentType,
+  normalizeSkillAutocompleteQuery,
+  normalizeSkillCapabilities,
   reloadSkills,
+  skillAutocompleteMatch,
   skillSourcePriorityForAgent,
 };

package/template/claude-task-manager/lib/skill-intent-resolver.js

@@ -0,0 +1,304 @@
+'use strict';
+
+const path = require('node:path');
+const skillAutocomplete = require('./skill-autocomplete');
+
+const SUPPORTED_INTENTS = Object.freeze({
+  finish_and_merge: true,
+  commit_main: true,
+  create_pr: true,
+});
+
+const MESSAGE_ONLY_REASON = 'message_only';
+let intentCache = new Map();
+
+function normalizeIntent(value) {
+  const text = String(value || '').trim().toLowerCase().replace(/[-\s]+/g, '_');
+  if (text === 'finish' || text === 'finish_merge' || text === 'merge_main') return 'finish_and_merge';
+  if (text === 'commit' || text === 'commit_local' || text === 'main_commit') return 'commit_main';
+  if (text === 'pr' || text === 'pull_request' || text === 'create_pull_request') return 'create_pr';
+  return SUPPORTED_INTENTS[text] ? text : '';
+}
+
+function resolveSkillIntent(options = {}) {
+  const intent = normalizeIntent(options.intent);
+  if (!intent) {
+    return {
+      ok: false,
+      error: 'unsupported_intent',
+      intent: String(options.intent || ''),
+      skill: null,
+      candidates: [],
+    };
+  }
+
+  const agent = skillAutocomplete.normalizeSkillAgentType(options.agent) || 'all';
+  const cwd = normalizeCwd(options.cwd);
+  const cacheKey = `${cwd}\0${agent}\0${intent}`;
+  const cached = intentCache.get(cacheKey);
+  if (cached) return cloneResult({ ...cached, cached: true });
+
+  const raw = skillAutocomplete.loadAllSkillEntries(cwd || undefined);
+  const compatible = raw
+    .filter((skill) => agent === 'all' || skillAutocomplete.isSkillCompatibleWithAgent(skill, agent))
+    .sort((a, b) => {
+      const sourceDelta = skillAutocomplete.skillSourcePriorityForAgent(a.source, agent) -
+        skillAutocomplete.skillSourcePriorityForAgent(b.source, agent);
+      if (sourceDelta) return sourceDelta;
+      return String(a.name || '').localeCompare(String(b.name || ''), undefined, {
+        numeric: true,
+        sensitivity: 'base',
+      });
+    });
+
+  const result = resolveSkillIntentFromSkills(compatible, { intent, agent, cwd });
+  intentCache.set(cacheKey, cloneResult({ ...result, cached: false }));
+  return cloneResult(result);
+}
+
+function resolveSkillIntentFromSkills(skills, options = {}) {
+  const intent = normalizeIntent(options.intent);
+  const agent = skillAutocomplete.normalizeSkillAgentType(options.agent) || 'all';
+  const assessed = safeArray(skills)
+    .map((skill, index) => assessSkillForIntent(skill, { intent, agent, index }))
+    .sort(compareIntentCandidates);
+  const candidates = assessed.filter((candidate) => candidate.score > 0 || candidate.eligible || candidate.negative.length > 0).slice(0, 12);
+  const selected = assessed.find((candidate) => candidate.eligible) || null;
+  return {
+    ok: true,
+    intent,
+    agent,
+    cwd: options.cwd || '',
+    cached: false,
+    generatedAt: new Date().toISOString(),
+    skill: selected ? publicCandidate(selected) : null,
+    candidates: candidates.map(publicCandidate),
+    totalSkills: safeArray(skills).length,
+  };
+}
+
+function assessSkillForIntent(skill, options = {}) {
+  const intent = normalizeIntent(options.intent);
+  const agent = skillAutocomplete.normalizeSkillAgentType(options.agent) || 'all';
+  const name = String(skill?.name || '').trim();
+  const source = String(skill?.source || '');
+  const description = String(skill?.description || '');
+  const text = searchableSkillText(skill);
+  const explicit = explicitCapabilities(skill);
+  const inferred = inferCapabilities(skill, explicit);
+  const caps = new Set([...explicit, ...inferred]);
+  const reasons = [];
+  const negative = [];
+  const messageOnly = isMessageOnlySkill(skill, text);
+  if (messageOnly) negative.push(MESSAGE_ONLY_REASON);
+
+  let eligible = false;
+  let score = 0;
+
+  if (intent === 'create_pr') {
+    eligible = !messageOnly && hasAny(caps, ['github.pr.create', 'git.pr.create', 'pr.create']);
+    score += add(capScore(caps, explicit, 'github.pr.create'), 'creates pull requests', reasons);
+    score += add(capScore(caps, explicit, 'git.review'), 'reviews changes', reasons);
+    score += add(capScore(caps, explicit, 'git.commit'), 'can commit before PR', reasons);
+    score += textBonus(/\bgithub\b|\bpull[- ]?request\b|\bcreate[- ]?pr\b|\bpr\b/, text, 8, 'PR language', reasons);
+  } else if (intent === 'commit_main') {
+    eligible = !messageOnly && hasAny(caps, ['git.commit']);
+    score += add(capScore(caps, explicit, 'git.commit'), 'commits local changes', reasons);
+    score += add(capScore(caps, explicit, 'git.review'), 'reviews before commit', reasons);
+    score += add(capScore(caps, explicit, 'git.quality'), 'quality gate', reasons);
+    score += textBonus(/\bsafe[- ]?commit\b|\breview[- ]?and[- ]?commit\b|\bpre[- ]?commit\b|\btl[- ]?commit\b/, text, 10, 'safe commit language', reasons);
+  } else if (intent === 'finish_and_merge') {
+    const canCommitOrFinish = hasAny(caps, ['git.commit', 'git.branch.finish']);
+    const canMerge = hasAny(caps, ['git.merge.main', 'git.branch.finish']);
+    eligible = !messageOnly && canCommitOrFinish && canMerge;
+    score += add(capScore(caps, explicit, 'git.commit'), 'commits local changes', reasons);
+    score += add(capScore(caps, explicit, 'git.merge.main'), 'merges to main', reasons);
+    score += add(capScore(caps, explicit, 'git.branch.finish'), 'finishes development branches', reasons);
+    score += add(capScore(caps, explicit, 'git.review'), 'reviews before integration', reasons);
+    score += add(capScore(caps, explicit, 'git.quality'), 'quality gate', reasons);
+    score += textBonus(/\bto main\b|\bmerge\b.*\bmain\b|\bintegrat\w*\b.*\bmain\b|\bfinish(?:ing)?[- ]a[- ]development[- ]branch\b/, text, 12, 'main integration language', reasons);
+  }
+
+  score += sourceBonus(source, agent);
+  const frequency = Number(skill?.frequency || 0);
+  if (Number.isFinite(frequency) && frequency > 0) score += Math.min(frequency, 20) / 20;
+  if (messageOnly) score -= 100;
+  if (!eligible) score = Math.max(0, score);
+
+  const prefix = invocationPrefixForSkill(skill, agent);
+  return {
+    skill,
+    name,
+    description,
+    source,
+    agents: Array.isArray(skill?.agents) ? skill.agents : [],
+    prefix,
+    intent,
+    agent,
+    score,
+    eligible,
+    capabilities: [...caps].sort(),
+    explicitCapabilities: [...explicit].sort(),
+    reasons,
+    negative,
+    originalIndex: Number.isFinite(options.index) ? options.index : 0,
+  };
+}
+
+function inferCapabilities(skill, explicit) {
+  const text = searchableSkillText(skill);
+  const caps = new Set();
+  const messageOnly = isMessageOnlySkill(skill, text);
+  if (!messageOnly && /\bcommit\b|\bstaged changes\b|\blocal changes\b/.test(text)) caps.add('git.commit');
+  if (/\breview\b|\baudit\b|\bverify\b|\bquality\b|\bpre[- ]?commit\b|\bsafe[- ]?commit\b|\btl[- ]?commit\b/.test(text)) caps.add('git.review');
+  if (/\bquality\b|\bsafe\b|\bsecurity\b|\bpii\b|\bsecret\b|\bpre[- ]?commit\b|\btl[- ]?commit\b/.test(text)) caps.add('git.quality');
+  if (/\bmerge\b.*\bmain\b|\bmain\b.*\bmerge\b|\bintegrat\w*\b.*\bmain\b|\bto main\b/.test(text)) caps.add('git.merge.main');
+  if (/\bfinish(?:ing)?[- ]a[- ]development[- ]branch\b|\bcomplete\b.*\bdevelopment work\b|\bguide\w*\b.*\bmerge\b.*\bpr\b.*\bcleanup\b/.test(text)) {
+    caps.add('git.branch.finish');
+    caps.add('git.merge.main');
+  }
+  if (/\bcreate\b.*\b(?:pr|pull[- ]?request)\b|\b(?:pr|pull[- ]?request)\b.*\bcreate\b|\bgithub\b.*\b(?:pr|pull[- ]?request)\b/.test(text)) {
+    caps.add('github.pr.create');
+  }
+  for (const cap of explicit) caps.add(cap);
+  return caps;
+}
+
+function explicitCapabilities(skill) {
+  const raw = [
+    ...safeArray(skill?.capabilities),
+    ...safeArray(skill?.intents),
+  ];
+  return new Set(skillAutocomplete.normalizeSkillCapabilities(raw).flatMap(expandCapabilityAlias));
+}
+
+function expandCapabilityAlias(value) {
+  const cap = String(value || '').toLowerCase();
+  const out = [cap];
+  if (cap === 'commit' || cap === 'git.commit.local') out.push('git.commit');
+  if (cap === 'review' || cap === 'code.review') out.push('git.review');
+  if (cap === 'quality' || cap === 'safety') out.push('git.quality');
+  if (cap === 'merge' || cap === 'merge.main' || cap === 'git.merge') out.push('git.merge.main');
+  if (cap === 'finish' || cap === 'finish.branch' || cap === 'branch.finish') out.push('git.branch.finish');
+  if (cap === 'pr' || cap === 'pull.request' || cap === 'github.pr') out.push('github.pr.create');
+  return out;
+}
+
+function isMessageOnlySkill(skill, text = searchableSkillText(skill)) {
+  const name = String(skill?.name || '').toLowerCase();
+  return /(?:^|[-_.:])commit[-_.:]?messages?(?:$|[-_.:])/.test(name) ||
+    /\bwriting[- ]commit[- ]messages?\b/.test(text) ||
+    /\bwrite\w*\b.*\bcommit messages?\b/.test(text) ||
+    /\bcommit message quality\b/.test(text) ||
+    /\bcommit message help\b/.test(text);
+}
+
+function invocationPrefixForSkill(skill, agentType) {
+  if (skill?.invocation === '$' || skill?.invocation === '/') return skill.invocation;
+  const agent = skillAutocomplete.normalizeSkillAgentType(agentType);
+  const source = String(skill?.source || '').toLowerCase();
+  if (agent === 'claude') return '/';
+  if (agent === 'codex' || agent === 'opencode' || agent === 'gemini') return '$';
+  if (source.startsWith('claude-')) return '/';
+  return '$';
+}
+
+function capScore(caps, explicit, cap) {
+  if (explicit.has(cap)) return 34;
+  if (caps.has(cap)) return 18;
+  return 0;
+}
+
+function add(value, reason, reasons) {
+  if (value > 0 && reason) reasons.push(reason);
+  return value;
+}
+
+function textBonus(pattern, text, score, reason, reasons) {
+  if (!pattern.test(text)) return 0;
+  if (reason) reasons.push(reason);
+  return score;
+}
+
+function sourceBonus(source, agent) {
+  const priority = skillAutocomplete.skillSourcePriorityForAgent(source, agent);
+  if (priority <= 1) return 3;
+  if (priority <= 3) return 2;
+  if (priority <= 5) return 1;
+  return 0;
+}
+
+function hasAny(caps, values) {
+  return values.some((value) => caps.has(value));
+}
+
+function compareIntentCandidates(a, b) {
+  if (a.eligible !== b.eligible) return a.eligible ? -1 : 1;
+  if (b.score !== a.score) return b.score - a.score;
+  const agent = a.intent === b.intent ? (a.agent || b.agent || 'all') : 'all';
+  const sourceDelta = skillAutocomplete.skillSourcePriorityForAgent(a.source, agent) -
+    skillAutocomplete.skillSourcePriorityForAgent(b.source, agent);
+  if (sourceDelta) return sourceDelta;
+  return String(a.name || '').localeCompare(String(b.name || ''), undefined, {
+    numeric: true,
+    sensitivity: 'base',
+  });
+}
+
+function publicCandidate(candidate) {
+  if (!candidate) return null;
+  return {
+    name: candidate.name,
+    description: candidate.description,
+    source: candidate.source,
+    agents: candidate.agents,
+    prefix: candidate.prefix,
+    invocation: candidate.prefix,
+    score: Math.round(candidate.score * 100) / 100,
+    eligible: !!candidate.eligible,
+    capabilities: candidate.capabilities,
+    reasons: candidate.reasons.slice(0, 5),
+    negative: candidate.negative,
+  };
+}
+
+function searchableSkillText(skill) {
+  return [
+    skill?.name,
+    skill?.description,
+    skill?.execution,
+    ...(Array.isArray(skill?.capabilities) ? skill.capabilities : []),
+    ...(Array.isArray(skill?.intents) ? skill.intents : []),
+  ].join(' ').toLowerCase().replace(/[_:./]+/g, ' ');
+}
+
+function normalizeCwd(value) {
+  const text = String(value || '').trim();
+  return text ? path.resolve(text) : '';
+}
+
+function safeArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function cloneResult(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function clearSkillIntentCache() {
+  intentCache = new Map();
+}
+
+function skillIntentCacheStats() {
+  return { entries: intentCache.size };
+}
+
+module.exports = {
+  assessSkillForIntent,
+  clearSkillIntentCache,
+  invocationPrefixForSkill,
+  normalizeIntent,
+  resolveSkillIntent,
+  resolveSkillIntentFromSkills,
+  skillIntentCacheStats,
+};

package/template/claude-task-manager/lib/sqlite-driver.js

@@ -124,7 +124,7 @@ function smokeTestDatabase(Database) {
   }
 }
 
-function runNpm(args, label) {
+function runNpm(args, label, extraEnv = {}) {
   const timeout = Number(process.env.CTM_SQLITE_REPAIR_TIMEOUT_MS || DEFAULT_REPAIR_TIMEOUT_MS);
   const started = Date.now();
   try {
@@ -135,9 +135,16 @@ function runNpm(args, label) {
       timeout: Number.isFinite(timeout) && timeout > 0 ? timeout : DEFAULT_REPAIR_TIMEOUT_MS,
       env: {
         ...process.env,
+        // Compile/resolve under the SAME Node that's loading the driver. Without this,
+        // execFileSync('npm') resolves `npm`/`node-gyp`/`node` from the ambient PATH (often
+        // a different Node major), so even a from-source rebuild targets the WRONG ABI and
+        // the brick persists. Prepending process.execPath's dir pins the toolchain to the
+        // running Node, so the rebuilt binary matches this process. This is the ABI-ping-pong fix.
+        PATH: `${path.dirname(process.execPath)}${path.delimiter}${process.env.PATH || ''}`,
         npm_config_audit: 'false',
         npm_config_fund: 'false',
         npm_config_update_notifier: 'false',
+        ...extraEnv,
       },
     });
     return { label, ok: true, ms: Date.now() - started, output: String(output || '').slice(-4000) };
@@ -155,9 +162,18 @@ function runNpm(args, label) {
 function defaultRepairRunner(cause) {
   const attempts = [];
   const spec = packageSpec();
+  // FROM-SOURCE FIRST. The node-ABI ping-pong: when several processes on different Node
+  // majors (e.g. the pinned 25.x primary + a system-26 dev/agent) share one node_modules,
+  // each one's load fails the ABI smoke test and triggers repair. Plain `npm rebuild` /
+  // `npm install` resolve a PREBUILT binary (or no-op "up to date") that is compiled for
+  // SOME other Node ABI — so the smoke test still fails and the primary bricks on restart.
+  // Forcing a source compile (`npm_config_build_from_source`) produces a binary matching
+  // THIS process's Node, so every process reliably self-heals instead of bricking.
+  const fromSource = { npm_config_build_from_source: 'true' };
   const commands = [
+    { label: 'npm rebuild better-sqlite3 (from source)', args: ['rebuild', 'better-sqlite3', '--foreground-scripts'], env: fromSource },
     { label: 'npm rebuild better-sqlite3', args: ['rebuild', 'better-sqlite3'] },
-    { label: `npm install better-sqlite3@${spec}`, args: ['install', `better-sqlite3@${spec}`, '--no-audit', '--no-fund'] },
+    { label: `npm install better-sqlite3@${spec} (from source)`, args: ['install', `better-sqlite3@${spec}`, '--no-audit', '--no-fund'], env: fromSource },
   ];
   if (process.env.CTM_SQLITE_ALLOW_MAJOR_UPGRADE !== '0' && spec !== 'latest') {
     commands.push({ label: 'npm install better-sqlite3@latest', args: ['install', 'better-sqlite3@latest', '--no-audit', '--no-fund'] });
@@ -168,7 +184,7 @@ function defaultRepairRunner(cause) {
       action: command.label,
       cause: String(cause?.message || cause || '').slice(0, 1000),
     });
-    const result = runNpm(command.args, command.label);
+    const result = runNpm(command.args, command.label, command.env || {});
     attempts.push(result);
     recordDriverEvent(result.ok ? 'sqlite_driver_repair_command_ok' : 'sqlite_driver_repair_command_failed', result);
     if (!result.ok) continue;

package/template/claude-task-manager/lib/standup-attention.js

@@ -3,6 +3,8 @@
 const crypto = require('crypto');
 
 const STICKY_ATTENTION_MS = 12 * 60 * 60 * 1000;
+const HARD_FAILURE_RE = /\b(cannot proceed|blocked|blocker|stuck|permission denied|fatal|panic|segmentation fault|uncaught|unhandled exception|traceback|command failed|build failed|tests? failed|npm err!|failed to run step|exceeded max retries|max retries|something went wrong)\b/i;
+const HARD_FAILURE_EVIDENCE_RE = /(cannot proceed|blocked|blocker|stuck|permission denied|fatal|unhandled exception|command failed|build failed|tests? failed|failed to run step|exceeded max retries|max retries|something went wrong)/i;
 
 function compactText(value) {
   if (!value) return '';
@@ -68,6 +70,7 @@ function attentionContextHash(text) {
 function buildStandupAttentionContext({ session = {}, summary = {}, status = {} } = {}) {
   const evidence = Array.isArray(summary.statusEvidence) ? summary.statusEvidence : [];
   const progress = summary.progress || {};
+  const terminalAttentionText = summary.terminalAttentionText || summary.terminal_attention_text || session.terminalAttentionText || '';
   const lines = [
     `Title: ${compactText(session.label || summary.displayPrompt || summary.lastPrompt || session.id || '')}`,
     `Agent: ${compactText(session.agentType || session.agent || session.type || '')}`,
@@ -77,6 +80,7 @@ function buildStandupAttentionContext({ session = {}, summary = {}, status = {}
     `Summary: ${compactText(summary.summary || '')}`,
     `Progress: ${compactText(progress)}`,
     `Evidence: ${evidence.map(compactText).filter(Boolean).join('; ')}`,
+    `Terminal: ${compactText(terminalAttentionText)}`,
   ].filter(line => !/:\s*$/.test(line));
   const text = truncateText(lines.join('\n'), 2500);
   return {
@@ -87,7 +91,7 @@ function buildStandupAttentionContext({ session = {}, summary = {}, status = {}
 }
 
 function hasAttentionLanguage(text) {
-  return /\b(warn(?:ing|ed)?|caution|risk|blocked|blocker|failed|failing|failure|error|exception|permission denied|cannot proceed|stuck|needs attention)\b/i.test(String(text || ''));
+  return /\b(warn(?:ing|ed)?|caution|risk|blocked|blocker|failed|failing|failure|error|exception|permission denied|cannot proceed|stuck|needs attention|exceeded max retries|max retries|something went wrong)\b/i.test(String(text || ''));
 }
 
 function hasResolutionSignal(text) {
@@ -98,7 +102,7 @@ function heuristicStandupAttention(context) {
   const text = String(context?.text || context || '');
   const lower = text.toLowerCase();
   const resolved = hasResolutionSignal(lower);
-  const hardFailure = /\b(cannot proceed|blocked|blocker|stuck|permission denied|fatal|panic|segmentation fault|uncaught|unhandled exception|traceback|command failed|build failed|tests? failed|npm err!)\b/i.test(lower);
+  const hardFailure = HARD_FAILURE_RE.test(lower);
   const warning = /\b(warn(?:ing|ed)?|caution|risk|heads up|possible issue|needs attention)\b/i.test(lower);
   const weakFailure = /\b(failed|failing|failure|error|exception)\b/i.test(lower);
 
@@ -109,7 +113,7 @@ function heuristicStandupAttention(context) {
     return normalizeAttention({
       severity: 'failure',
       recommendation: 'A current blocker or failure appears to need attention.',
-      evidence: [firstMatchingPhrase(text, /(cannot proceed|blocked|blocker|stuck|permission denied|fatal|unhandled exception|command failed|build failed|tests? failed)/i)],
+      evidence: [firstMatchingPhrase(text, HARD_FAILURE_EVIDENCE_RE)],
       source: 'heuristic',
       confidence: 'medium',
     });

package/template/claude-task-manager/lib/status-authority.js

@@ -0,0 +1,39 @@
+'use strict';
+// Status authority inversion.
+//
+// CTM derives session status from two kinds of evidence:
+//   1. Structured signals — OTLP telemetry (codex) and provider hooks
+//      (claude/gemini), surfaced via lib/telemetry-receiver. These say
+//      exactly when a turn starts and ends.
+//   2. PTY byte inference — provider state detectors classifying raw
+//      terminal chunks (workers/state-detectors/*).
+//
+// Byte inference is inherently low-precision for full-screen TUIs: an idle
+// codex still repaints (background MCP/rate-limit fetches, focus events,
+// animation frames), and one misclassified chunk holds the sidebar on
+// "Running" for the provider's whole idle-debounce window. So when a
+// structured source owns a session, generic bytes must not CREATE a running
+// state out of idle — only the provider's own busy-status line ("Working …
+// esc to interrupt", matched strictly) or the structured source itself may.
+//
+// Two deliberate escape hatches keep this safe:
+//   - No structured source (fresh install, otel/notify not configured):
+//     full byte inference remains, it is the only signal available.
+//   - Provider without a precise busy channel (no textHasCodexBusyStatus
+//     on its detector): never strand it — its hooks can lag and generic
+//     output is the only unstick signal it has.
+
+function ptyActivityMayDriveRunning({
+  hasAuthoritativeSource = false,
+  busyEvidenceCapable = false,
+  lastBusyStatusAt = 0,
+  now = Date.now(),
+  busyHoldMs = 15000,
+} = {}) {
+  if (!hasAuthoritativeSource) return true;
+  if (!busyEvidenceCapable) return true;
+  const busyAt = Number(lastBusyStatusAt) || 0;
+  return !!(busyAt && (now - busyAt) < busyHoldMs);
+}
+
+module.exports = { ptyActivityMayDriveRunning };

package/template/claude-task-manager/lib/status-hooks.js

@@ -60,6 +60,9 @@ function onApprovalDetected(sessionId) {
 function onApprovalResolved(sessionId) {
   bus.onApprovalResolved(sessionId);
 }
+function clearWaitingInput(sessionId) {
+  bus.clearWaitingInput(sessionId);
+}
 
 // Wire bus events → hook-executor.
 bus.on('statechange', async (ev) => {
@@ -101,6 +104,7 @@ module.exports = {
   onOutput,
   onApprovalDetected,
   onApprovalResolved,
+  clearWaitingInput,
   // Introspection / tests
   _bus: bus,
   _sessionMeta,