ultra-builder-pro-cli 0.14.0 → 0.16.0

package/ultra-tools/commands/status.cjs

@@ -1,20 +1,24 @@
 'use strict';
 
-// Phase 6.3 — ultra-tools status cost panel.
+// Ultra project status panel.
 //
-// Reads telemetry aggregations from state.db (Phase 6.2) and renders either
-// a human-readable table or a JSON envelope consumable by skills/ultra-status.
-// Does not modify state — read-only command.
+// Reads project authority and telemetry from state.db and renders either a
+// human-readable report or a JSON envelope consumable by skills/ultra-status.
+// Does not modify state.
 
 const fs = require('node:fs');
 const path = require('node:path');
 
 const ops = require('../../mcp-server/lib/state-ops.cjs');
 const baselines = require('../../mcp-server/lib/baseline-workflow.cjs');
+const workflowState = require('../../mcp-server/lib/workflow-state.cjs');
+const decisionDialogue = require('../../mcp-server/lib/decision-dialogue.cjs');
+const { readBreadcrumb } = require('../../mcp-server/lib/context-spine.cjs');
 
 const USAGE = `ultra-tools status [flags]
 
-Reads telemetry from .ultra/state.db and prints a cost + activity summary.
+Reads .ultra/state.db and prints baseline, workflow, task, session, route, and
+cost-observability status.
 
 FLAGS:
   --cost            include per-runtime + top-tasks cost panel (default on)
@@ -65,10 +69,25 @@ function parseFlags(args) {
   return out;
 }
 
-function buildCostPanel(db, { since = null, limit = 3, rootDir = process.cwd() } = {}) {
-  const by_runtime = ops.aggregateTelemetryByRuntime(db, { since });
-  const top_tasks = ops.aggregateTelemetryByTask(db, { since, limit });
-  const total_cost_usd = by_runtime.reduce((acc, r) => acc + (r.cost_usd || 0), 0);
+function buildStatusPanel(db, { since = null, limit = 3, rootDir = process.cwd() } = {}) {
+  const tables = new Set(db.prepare(
+    "SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'",
+  ).all().map((row) => row.name));
+  const by_runtime = tables.has('telemetry') && tables.has('sessions')
+    ? ops.aggregateTelemetryByRuntime(db, { since }) : [];
+  const top_tasks = tables.has('telemetry') && tables.has('sessions')
+    ? ops.aggregateTelemetryByTask(db, { since, limit }) : [];
+  const knownTotalCost = by_runtime.reduce((acc, r) => acc + (r.cost_usd || 0), 0);
+  const unpricedUsageEvents = by_runtime.reduce(
+    (acc, row) => acc + Number(row.unpriced_usage_events || 0), 0,
+  );
+  const pricedUsageEvents = by_runtime.reduce(
+    (acc, row) => acc + Number(row.priced_usage_events || 0), 0,
+  );
+  const costStatus = unpricedUsageEvents > 0
+    ? (pricedUsageEvents > 0 ? 'partial' : 'unavailable')
+    : (pricedUsageEvents > 0 ? 'complete' : 'none');
+  const total_cost_usd = unpricedUsageEvents > 0 ? null : knownTotalCost;
   const baselineHealth = baselines.inspectBaseline(db, { rootDir });
   const current = baselineHealth.baseline;
   const baselineStatus = current?.status
@@ -87,16 +106,172 @@ function buildCostPanel(db, { since = null, limit = 3, rootDir = process.cwd() }
     baseline.repository_branch = current.repository_branch || null;
     baseline.worktree_state = current.worktree_state || 'unavailable';
     baseline.gaps = baselines.summarizeGaps(current.gaps);
+    if (current.research_run_id && tables.has('workflow_runs') && tables.has('workflow_steps')) {
+      const research = workflowState.readWorkflow(db, current.research_run_id, { rootDir });
+      baseline.research = research ? {
+        id: research.id,
+        status: research.status,
+        mode: research.mode,
+        output_health: research.artifact_health.status,
+        blockers: research.artifact_health.blockers,
+      } : {
+        id: current.research_run_id, status: 'missing', mode: null,
+        output_health: 'fail', blockers: ['BASELINE_RESEARCH_RECORD_INVALID'],
+      };
+    }
+  }
+  const countStatuses = (table, statuses, where = '') => {
+    if (!tables.has(table)) {
+      return {
+        status: 'unavailable',
+        ...Object.fromEntries(statuses.map((status) => [status, 0])),
+      };
+    }
+    const rows = db.prepare(
+      `SELECT status, COUNT(*) AS count FROM ${table} ${where} GROUP BY status`,
+    ).all();
+    const counts = Object.fromEntries(statuses.map((status) => [status, 0]));
+    for (const row of rows) if (row.status in counts) counts[row.status] = Number(row.count);
+    return counts;
+  };
+  const taskCounts = countStatuses(
+    'tasks', ['pending', 'in_progress', 'completed', 'blocked', 'expanded'],
+  );
+  taskCounts.stale = tables.has('tasks')
+    ? Number(db.prepare('SELECT COUNT(*) AS count FROM tasks WHERE stale = 1').get().count) : 0;
+  const sessions = countStatuses('sessions', ['running', 'completed', 'crashed', 'orphan']);
+  const changes = countStatuses('changes', ['active', 'blocked', 'ready', 'archived', 'cancelled']);
+  let workflows;
+  try {
+    if (!tables.has('workflow_runs') || !tables.has('workflow_steps')) {
+      workflows = {
+        status: 'unavailable', active: 0, blocked: 0, ready: 0,
+        stale_outputs: [], historical_stale_outputs: [],
+        terminal_authority_runs: [], untracked_active_changes: [],
+      };
+    } else {
+      workflows = workflowState.inspectWorkflowHealth(db, { rootDir });
+      workflows.current = workflowState.listWorkflows(db, { limit: 500 }, { rootDir })
+        .filter((run) => ['active', 'blocked', 'ready'].includes(run.status))
+        .map((run) => ({
+          id: run.id, kind: run.kind, status: run.status, current_step: run.current_step,
+          baseline_id: run.baseline_id, change_id: run.change_id, task_id: run.task_id,
+          blockers: run.blockers, output_health: run.artifact_health.status,
+        }));
+    }
+  } catch (error) {
+    workflows = {
+      status: 'fail', active: 0, blocked: 0, ready: 0,
+      stale_outputs: [], historical_stale_outputs: [],
+      terminal_authority_runs: [], untracked_active_changes: [],
+      error: error.code || error.message,
+    };
+  }
+  if (!Array.isArray(workflows.current)) workflows.current = [];
+  const decisions = tables.has('decision_threads') && tables.has('decision_items')
+    ? decisionDialogue.inspectDecisionHealth(db, { rootDir })
+    : {
+      status: 'unavailable', active: 0, awaiting_owner: 0, checkpoint_ready: 0,
+      deferred_blocking: 0, stale_artifacts: [], current: null, current_thread_id: null,
+    };
+  let next;
+  let breadcrumb = null;
+  try {
+    if (!tables.has('baselines')) {
+      next = {
+        action: 'Resume project initialization to migrate and establish baseline authority.',
+        recommended_workflow: 'ultra-init', readiness: 'blocked',
+        blockers: ['BASELINE_SCHEMA_MIGRATION_REQUIRED'], warnings: [],
+      };
+    } else {
+    breadcrumb = readBreadcrumb(db, {}, { rootDir });
+    next = {
+      action: breadcrumb.next_action,
+      recommended_workflow: breadcrumb.recommended_workflow,
+      readiness: breadcrumb.readiness,
+      blockers: breadcrumb.blockers,
+      warnings: breadcrumb.warnings,
+      change_id: breadcrumb.change_id || null,
+      task_id: breadcrumb.task_id || null,
+      workflow: breadcrumb.workflow || null,
+    };
+    }
+  } catch (error) {
+    next = {
+      action: 'Run ultra-doctor to inspect authoritative state.',
+      recommended_workflow: 'ultra-doctor', readiness: 'blocked',
+      blockers: [`STATUS_AUTHORITY_UNAVAILABLE:${error.code || 'unknown'}`], warnings: [],
+    };
+  }
+
+  const currentChange = tables.has('changes')
+    ? db.prepare(
+      `SELECT id, title, kind, status, intent, base_commit, artifact_root, updated_at
+       FROM changes
+       WHERE status IN ('active', 'blocked', 'ready')
+       ORDER BY updated_at DESC, rowid DESC LIMIT 1`,
+    ).get() || null
+    : null;
+  const evidenceChangeId = breadcrumb?.change_id || currentChange?.id
+    || (tables.has('changes') ? db.prepare(
+      `SELECT id FROM changes WHERE status = 'archived'
+       ORDER BY updated_at DESC, rowid DESC LIMIT 1`,
+    ).get()?.id : null);
+  let currentTask = null;
+  if (tables.has('tasks')) {
+    const taskId = breadcrumb?.task_id || (currentChange?.id ? db.prepare(
+      `SELECT id FROM tasks WHERE change_id = ?
+       ORDER BY CASE status WHEN 'in_progress' THEN 0 WHEN 'blocked' THEN 1
+                WHEN 'pending' THEN 2 ELSE 3 END, priority ASC, created_at ASC LIMIT 1`,
+    ).get(currentChange.id)?.id : null);
+    if (taskId) currentTask = ops.readTask(db, taskId);
+  }
+  const evidence = {};
+  for (const kind of ['test', 'review', 'deliver']) {
+    const run = evidenceChangeId && tables.has('workflow_runs') && tables.has('workflow_steps')
+      ? workflowState.listWorkflows(
+        db, { kind, status: 'completed', change_id: evidenceChangeId, limit: 1 }, { rootDir },
+      )[0]
+      : null;
+    let status = 'missing';
+    if (run && kind === 'test') status = run.summary.passed === true ? 'pass' : 'fail';
+    if (run && kind === 'review') status = run.summary.verdict || 'unknown';
+    if (run && kind === 'deliver') {
+      status = run.summary.archive_status === 'archived' ? 'delivered' : 'incomplete';
+    }
+    const evidenceKey = kind === 'deliver' ? 'delivery' : kind;
+    evidence[evidenceKey] = run ? {
+      workflow_id: run.id, status, output_health: run.artifact_health.status,
+      report_path: run.summary.report_path || null,
+    } : { workflow_id: null, status: 'missing', output_health: 'missing', report_path: null };
   }
   return {
     period: { since: since || 'all-time' },
     baseline,
+    workflows,
+    decisions,
+    current_change: currentChange,
+    current_task: currentTask,
+    evidence,
+    changes,
+    tasks: taskCounts,
+    sessions,
+    next,
     by_runtime,
     top_tasks,
     total_cost_usd,
+    cost: {
+      status: costStatus,
+      known_total_usd: knownTotalCost,
+      priced_usage_events: pricedUsageEvents,
+      unpriced_usage_events: unpricedUsageEvents,
+    },
   };
 }
 
+// Backward-compatible internal export for consumers that used the old name.
+const buildCostPanel = buildStatusPanel;
+
 function formatCost(n) {
   if (!n) return '$0.0000';
   if (n < 0.01) return `$${n.toFixed(6)}`;
@@ -107,11 +282,51 @@ function renderHuman(panel) {
   const lines = [];
   const baseline = panel.baseline;
   lines.push(
-    `Baseline: ${baseline.mode || 'none'}/${baseline.status} · ${baseline.health === 'pass' ? 'ready' : 'blocked'}`,
+    `Baseline: ${baseline.mode || 'none'}/${baseline.status} · ${baseline.health === 'pass' ? 'ready' : 'blocked'}`
+      + (baseline.research ? ` · research=${baseline.research.id}/${baseline.research.status}/${baseline.research.output_health}` : ''),
   );
   if (baseline.blockers.length > 0) lines.push(`Baseline blockers: ${baseline.blockers.join(', ')}`);
+  lines.push(
+    `Workflows: active=${panel.workflows.active} blocked=${panel.workflows.blocked} ready=${panel.workflows.ready} health=${panel.workflows.status}`,
+  );
+  if (panel.workflows.current.length > 0) {
+    const current = panel.workflows.current[0];
+    lines.push(
+      `Workflow: ${current.id} (${current.kind}/${current.status}) · step=${current.current_step || 'finalize'} · outputs=${current.output_health}`,
+    );
+  }
+  if (panel.decisions.current) {
+    lines.push(
+      `Decision: ${panel.decisions.current.id} (${panel.decisions.current.phase}) — ${panel.decisions.current.question}`,
+    );
+  } else if (panel.decisions.checkpoint_ready > 0) {
+    lines.push(`Decision checkpoint: ${panel.decisions.current_thread_id} awaits confirmation`);
+  }
+  lines.push(
+    `Changes: active=${panel.changes.active} blocked=${panel.changes.blocked} ready=${panel.changes.ready} archived=${panel.changes.archived}`,
+  );
+  lines.push(
+    `Tasks: pending=${panel.tasks.pending} in_progress=${panel.tasks.in_progress} completed=${panel.tasks.completed} blocked=${panel.tasks.blocked} stale=${panel.tasks.stale}`,
+  );
+  if (panel.current_change) {
+    lines.push(`Current change: ${panel.current_change.id} (${panel.current_change.status})`);
+  }
+  if (panel.current_task) lines.push(`Current task: ${panel.current_task.id} (${panel.current_task.status})`);
+  lines.push(
+    `Sessions: running=${panel.sessions.running} crashed=${panel.sessions.crashed} orphan=${panel.sessions.orphan}`,
+  );
+  lines.push(`Next: ${panel.next.action} (${panel.next.recommended_workflow})`);
+  lines.push(
+    `Evidence: test=${panel.evidence.test.status} review=${panel.evidence.review.status} delivery=${panel.evidence.delivery.status}`,
+  );
   lines.push(`Period: ${panel.period.since}`);
-  lines.push(`Total cost: ${formatCost(panel.total_cost_usd)}`);
+  if (panel.total_cost_usd === null) {
+    lines.push(
+      `Total cost: unavailable (${panel.cost.unpriced_usage_events} unpriced usage events; known cost ${formatCost(panel.cost.known_total_usd)})`,
+    );
+  } else {
+    lines.push(`Total cost: ${formatCost(panel.total_cost_usd)}`);
+  }
   lines.push('');
   lines.push('Cost by runtime:');
   if (panel.by_runtime.length === 0) {
@@ -163,7 +378,7 @@ function dispatch(args) {
   const db = new Database(dbPath, { readonly: true });
   try {
     const rootDir = path.dirname(path.dirname(dbPath));
-    const panel = buildCostPanel(db, { since, limit: flags.limit, rootDir });
+    const panel = buildStatusPanel(db, { since, limit: flags.limit, rootDir });
     if (flags.json) {
       emit({ ok: true, data: panel });
     } else {
@@ -178,6 +393,7 @@ function dispatch(args) {
 module.exports = {
   USAGE,
   dispatch,
+  buildStatusPanel,
   buildCostPanel,
   renderHuman,
   parseSince,

package/.ultra-template/delivery-report.json

@@ -1,9 +0,0 @@
-{
-  "timestamp": null,
-  "version": null,
-  "git_tag": null,
-  "git_commit": null,
-  "changelog_updated": false,
-  "build_success": false,
-  "pushed": false
-}

package/.ultra-template/test-report.json

@@ -1,8 +0,0 @@
-{
-  "passed": false,
-  "run_count": 0,
-  "timestamp": null,
-  "git_commit": null,
-  "gates": {},
-  "blocking_issues": ["Not yet run"]
-}

package/adapters/_shared/tests/file-ops.test.cjs

@@ -1,54 +0,0 @@
-'use strict';
-
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const { copyTree, writeAtomic, removeTree } = require('../file-ops.cjs');
-
-function mk(prefix = 'ubp-shared-') {
-  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-}
-
-test('copyTree copies recursively and skips .DS_Store', () => {
-  const src = mk();
-  const dst = mk();
-  try {
-    fs.mkdirSync(path.join(src, 'nested'));
-    fs.writeFileSync(path.join(src, 'a.txt'), 'A');
-    fs.writeFileSync(path.join(src, '.DS_Store'), 'junk');
-    fs.writeFileSync(path.join(src, 'nested', 'b.txt'), 'B');
-
-    const files = copyTree(src, dst);
-    assert.deepEqual(files.sort(), ['a.txt', path.join('nested', 'b.txt')]);
-    assert.equal(fs.readFileSync(path.join(dst, 'a.txt'), 'utf8'), 'A');
-    assert.equal(fs.readFileSync(path.join(dst, 'nested', 'b.txt'), 'utf8'), 'B');
-    assert.ok(!fs.existsSync(path.join(dst, '.DS_Store')));
-  } finally {
-    removeTree(src);
-    removeTree(dst);
-  }
-});
-
-test('writeAtomic never leaves a torn write — tmp file is renamed', () => {
-  const dir = mk();
-  try {
-    const target = path.join(dir, 'out', 'file.txt');
-    writeAtomic(target, 'hello');
-    assert.equal(fs.readFileSync(target, 'utf8'), 'hello');
-
-    const siblings = fs.readdirSync(path.dirname(target));
-    assert.deepEqual(siblings, ['file.txt']);  // no .tmp-* left behind
-  } finally {
-    removeTree(dir);
-  }
-});
-
-test('removeTree refuses to wipe filesystem root without allowRoot', () => {
-  assert.throws(
-    () => removeTree('/', { allowRoot: false }),
-    /refusing to remove filesystem root/,
-  );
-});

package/adapters/_shared/tests/frontmatter.test.cjs

@@ -1,47 +0,0 @@
-'use strict';
-
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-
-const { parse, serialize, lowercaseKeys, patch } = require('../frontmatter.cjs');
-
-test('parse extracts frontmatter and body; degraded inputs survive', () => {
-  const withFm = '---\ndescription: hi\nmodel: opus\n---\n\n# Hello\n';
-  const out = parse(withFm);
-  assert.equal(out.fm.description, 'hi');
-  assert.equal(out.fm.model, 'opus');
-  assert.ok(out.body.startsWith('# Hello'));
-
-  // no delimiter at all
-  const plain = parse('# No frontmatter\n');
-  assert.equal(plain.fm, null);
-  assert.equal(plain.body, '# No frontmatter\n');
-
-  // delimiter open but never closed — treat as plain text
-  const unclosed = parse('---\nfoo: 1\nno closing delimiter\n');
-  assert.equal(unclosed.fm, null);
-  assert.ok(unclosed.body.includes('no closing delimiter'));
-
-  // type guard
-  assert.throws(() => parse(42), /expects string/);
-});
-
-test('serialize → parse round-trip preserves data', () => {
-  const fm = { description: 'round-trip', tags: ['a', 'b'] };
-  const body = '# Body\n\nparagraph\n';
-  const text = serialize(fm, body);
-  const { fm: got, body: gotBody } = parse(text);
-  assert.deepEqual(got, fm);
-  assert.equal(gotBody, body);
-});
-
-test('lowercaseKeys normalizes nested frontmatter (OpenCode contract)', () => {
-  const input = { Name: 'X', TAGS: ['T1'], Nested: { Key: 1 } };
-  const out = lowercaseKeys(input);
-  assert.deepEqual(out, { name: 'X', tags: ['T1'], nested: { key: 1 } });
-
-  // patch() should let callers transform fm in-place
-  const patched = patch('---\nFoo: 1\n---\nbody', (fm) => ({ foo: fm.Foo }));
-  const { fm } = parse(patched);
-  assert.deepEqual(fm, { foo: 1 });
-});

package/adapters/_shared/tests/handbook.test.cjs

@@ -1,101 +0,0 @@
-'use strict';
-
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const test = require('node:test');
-
-const {
-  BEGIN_MARKER,
-  END_MARKER,
-  applyHandbook,
-  mergeHandbook,
-  renderHandbook,
-  resolveHandbookFile,
-} = require('../handbook.cjs');
-
-test('renders one common contract with host-native invocation syntax', () => {
-  const claude = renderHandbook('claude');
-  const codex = renderHandbook('codex');
-  const opencode = renderHandbook('opencode');
-  const kimi = renderHandbook('kimi');
-
-  assert.match(claude, /\/ultra-plan/);
-  assert.match(codex, /\$ultra-builder-pro:ultra-plan/);
-  assert.match(opencode, /\/ultra-plan/);
-  assert.match(kimi, /\/ultra-builder-pro:ultra-plan/);
-  assert.match(kimi, /Kimi Code/);
-  assert.match(kimi, /AgentSwarm/);
-  for (const rendered of [claude, codex, opencode, kimi]) {
-    assert.match(rendered, /\.ultra\/state\.db/);
-    assert.match(rendered, /Separately installed providers/);
-    assert.match(rendered, /ultra-change/);
-    assert.match(rendered, /ultra-doctor/);
-    assert.match(rendered, /metadata references/);
-    assert.match(rendered, /Context Spine boundary/);
-    assert.match(rendered, /budgets are advisory attention signals/);
-    assert.match(rendered, /blocks change convergence/);
-    assert.match(rendered, /health-checked atomically at archive/);
-    assert.match(rendered, /never traps session stop/);
-    assert.match(rendered, /change\.breadcrumb/);
-    assert.match(rendered, /Specification learning boundary/);
-    assert.doesNotMatch(rendered, /\.ultra\/memory|memory\.retain|memory\.recall/);
-    assert.match(rendered, new RegExp(BEGIN_MARKER.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
-    assert.match(rendered, new RegExp(END_MARKER.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
-  }
-});
-
-test('merge preserves user content and is idempotent', () => {
-  const existing = '# User rules\n\nKeep this.\n';
-  const once = mergeHandbook(existing, 'claude');
-  const twice = mergeHandbook(once, 'claude');
-
-  assert.match(once, /^# User rules/m);
-  assert.match(once, /Keep this\./);
-  assert.equal(once, twice);
-  assert.equal(once.split(BEGIN_MARKER).length - 1, 1);
-});
-
-test('Codex legacy Ultra section is replaced without touching the next section', () => {
-  const existing = [
-    '# Handbook',
-    '',
-    '## Ultra Builder Pro Runtime Contract',
-    '',
-    'Old memory contract under `.ultra/memory/`.',
-    '',
-    '## Standard Operating Workflow',
-    '',
-    'Keep this workflow.',
-    '',
-  ].join('\n');
-
-  const merged = mergeHandbook(existing, 'codex');
-  assert.doesNotMatch(merged, /Old memory contract/);
-  assert.match(merged, /## Standard Operating Workflow\n\nKeep this workflow\./);
-  assert.equal(merged.split(BEGIN_MARKER).length - 1, 1);
-});
-
-test('apply creates a backup and reports a no-op on the second run', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-handbook-'));
-  const file = path.join(root, 'AGENTS.md');
-  fs.writeFileSync(file, '# Existing\n');
-
-  const first = applyHandbook({ runtime: 'codex', file, now: '20260715T120000Z' });
-  assert.equal(first.changed, true);
-  assert.equal(first.backup, `${file}.ubp-backup-20260715T120000Z`);
-  assert.equal(fs.readFileSync(first.backup, 'utf8'), '# Existing\n');
-
-  const second = applyHandbook({ runtime: 'codex', file, now: '20260715T120001Z' });
-  assert.equal(second.changed, false);
-  assert.equal(second.backup, null);
-});
-
-test('default handbook paths are host-specific', () => {
-  const homeDir = '/tmp/example-home';
-  assert.equal(resolveHandbookFile('claude', { homeDir }), path.join(homeDir, '.claude', 'CLAUDE.md'));
-  assert.equal(resolveHandbookFile('codex', { homeDir }), path.join(homeDir, '.codex', 'AGENTS.md'));
-  assert.equal(resolveHandbookFile('opencode', { homeDir }), path.join(homeDir, '.config', 'opencode', 'AGENTS.md'));
-  assert.equal(resolveHandbookFile('kimi', { homeDir }), path.join(homeDir, '.kimi-code', 'AGENTS.md'));
-});

package/adapters/_shared/tests/path-rewrite.test.cjs

@@ -1,60 +0,0 @@
-'use strict';
-
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-const path = require('node:path');
-
-const {
-  parseSkillRef,
-  resolveSkillRef,
-  rewriteWorkflowRefInText,
-  resolveAssetTarget,
-} = require('../path-rewrite.cjs');
-
-test('parseSkillRef accepts canonical @skills/<slug>/SKILL.md only', () => {
-  assert.deepEqual(parseSkillRef('@skills/ultra-init/SKILL.md'), {
-    name: 'ultra-init',
-    filename: 'SKILL.md',
-  });
-  assert.equal(parseSkillRef('skills/ultra-init/SKILL.md'), null); // missing @
-  assert.equal(parseSkillRef('@skills/Bad-Case/SKILL.md'), null);   // uppercase slug
-  assert.equal(parseSkillRef(null), null);
-});
-
-test('resolveSkillRef routes to runtime-specific root under homeDir', () => {
-  const home = '/Users/test';
-  const claude = resolveSkillRef('@skills/ultra-init/SKILL.md', { runtime: 'claude', homeDir: home });
-  const opencode = resolveSkillRef('@skills/ultra-init/SKILL.md', { runtime: 'opencode', homeDir: home });
-  const codex = resolveSkillRef('@skills/ultra-init/SKILL.md', { runtime: 'codex', homeDir: home });
-  const kimi = resolveSkillRef('@skills/ultra-init/SKILL.md', { runtime: 'kimi', homeDir: home });
-
-  assert.equal(claude, path.join(home, '.claude/skills/ultra-init/SKILL.md'));
-  assert.equal(opencode, path.join(home, '.config/opencode/skills/ultra-init/SKILL.md'));
-  assert.equal(codex, path.join(home, '.agents/skills/ultra-init/SKILL.md'));
-  assert.equal(kimi, path.join(home, '.kimi-code/skills/ultra-init/SKILL.md'));
-
-  assert.throws(
-    () => resolveSkillRef('@skills/ultra-init/SKILL.md', { runtime: 'unknown', homeDir: home }),
-    /unknown runtime/,
-  );
-});
-
-test('rewriteWorkflowRefInText + resolveAssetTarget give predictable paths', () => {
-  const home = '/h';
-  const cwd = '/w';
-  const input = 'see @skills/ultra-init/SKILL.md for details';
-  const out = rewriteWorkflowRefInText(input, { runtime: 'claude', homeDir: home });
-  assert.equal(out, `see ${path.join(home, '.claude/skills/ultra-init/SKILL.md')} for details`);
-
-  // Cover every runtime × every scope so runtimeRoot/localRoot branches hit
-  for (const rt of ['claude', 'opencode', 'codex', 'kimi']) {
-    const g = resolveAssetTarget('x', { runtime: rt, scope: 'global', homeDir: home, cwd });
-    const l = resolveAssetTarget('x', { runtime: rt, scope: 'local', homeDir: home, cwd });
-    assert.ok(g.startsWith(home));
-    assert.ok(l.startsWith(cwd));
-  }
-  assert.throws(
-    () => resolveAssetTarget('x', { runtime: 'unknown', scope: 'global', homeDir: home, cwd }),
-    /unknown runtime/,
-  );
-});