@justjoshn/pi-pstack 0.15.36-pi.1 → 0.15.36-pi.8

package/src/task/tool.ts

@@ -1,19 +1,20 @@
 import { randomUUID } from 'node:crypto';
 import { existsSync, rmSync } from 'node:fs';
-import { basename, join } from 'node:path';
+import { join } from 'node:path';
 
-import { getSupportedThinkingLevels, StringEnum } from '@earendil-works/pi-ai';
+import { getSupportedThinkingLevels } from '@earendil-works/pi-ai';
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
 import { type Static, Type } from 'typebox';
 import { childIdentity, childVariables } from '../child-env.ts';
 import { rootStoreDir, subagentDir, workspaceStateDir, worktreesDir } from '../paths.ts';
+import { piCommand } from '../pi-command.ts';
 import { type AgentDefinition, findAgent } from './agents.ts';
-import { renderTaskCard } from './card.ts';
+import { renderTaskCard, renderTaskNotification } from './card.ts';
 import { backgroundText, bounded, foregroundText, steerText, worktreeLine, worktreePreface } from './format.ts';
 import { type AvailableModel, type ModelSpec, resolveSubagentModel } from './models.ts';
 import { type AgentRecord, acquireRunLock, forkTranscript, type RunLock, readonlyLaunchRestores, readRecord, transcriptFor, writeRecord } from './records.ts';
-import { type BackgroundNotice, createSubagentRegistry } from './registry.ts';
-import { type ChildHandle, type ChildOutcome, childArgs, resolveAttachments, startChild, validateAgentId, withAttachments } from './runner.ts';
+import { type BackgroundNotice, createSubagentRegistry, NOTIFICATION_TYPE } from './registry.ts';
+import { type ChildHandle, type ChildInput, type ChildOutcome, childArgs, resolveAttachments, startChild, validateAgentId, withAttachments } from './runner.ts';
 import { registerStopAgent } from './stop.ts';
 import { addWorktree, planWorktree, type Worktree } from './worktree.ts';
 
@@ -50,7 +51,8 @@ export const TaskParams = Type.Object({
   ),
   file_attachments: Type.Optional(Type.Array(Type.String(), { description: 'Paths of files or images to attach to the agent first message.' })),
   environment: Type.Optional(
-    StringEnum(['local', 'cloud'] as const, {
+    Type.Enum(['local', 'cloud'] as const, {
+      type: 'string',
       description:
         'local (default) runs the agent in this working directory. cloud runs it on this machine in its own git worktree on a new branch pstack/<agent id>, created from cloud_base_branch or the current HEAD commit, so uncommitted changes do not reach it. The result names the worktree and branch; merge the branch to take its commits. Ignored with resume; not allowed with fork.',
     }),
@@ -101,13 +103,6 @@ export interface Launch {
 
 const runsReadonly = (plan: Launch) => plan.readonly || plan.planMode;
 
-/** The running pi script, so children match the parent's Pi version; falls back to `pi` on PATH. */
-function piCommand(): string[] {
-  const script = process.argv[1];
-  if (script !== undefined && !script.startsWith('/$bunfs/') && existsSync(script)) return [process.execPath, script];
-  return /^(node|bun)(\.exe)?$/.test(basename(process.execPath).toLowerCase()) ? ['pi'] : [process.execPath];
-}
-
 export function availableModels(ctx: ExtensionContext): AvailableModel[] {
   return ctx.modelRegistry.getAvailable().map((model) => ({ provider: model.provider, id: model.id, reasoning: model.reasoning, levels: getSupportedThinkingLevels(model) }));
 }
@@ -219,13 +214,12 @@ export function planFork(params: TaskInput, ctx: ExtensionContext, agents: reado
   };
 }
 
-function launchChild(plan: Launch, prompt: string, signal: AbortSignal | undefined) {
+function launchChild(plan: Launch, input: ChildInput, signal: AbortSignal | undefined) {
   const readonly = runsReadonly(plan);
   const env = { ...process.env, ...childVariables(plan.agent.type, plan.depth, readonly, plan.rootStore, workspaceStateDir(plan.workspace)) };
   const transcript = plan.kind === 'fresh' || readonly ? undefined : transcriptFor(subagentDir(plan.workspace), plan.agentId);
   const restoreTools = transcript === undefined ? [] : readonlyLaunchRestores(transcript);
   const args = childArgs({ sessionDir: subagentDir(plan.workspace), agentId: plan.agentId, readonly, restoreTools, trusted: plan.trusted, ...(plan.model === undefined ? {} : { model: plan.model }) });
-  const input = withAttachments(prompt, plan.attachments);
   return startChild({ command: piCommand(), args, prompt: input.text, images: input.images, cwd: plan.worktree?.cwd ?? plan.workspace, env, ...(signal === undefined ? {} : { signal }) });
 }
 
@@ -256,10 +250,11 @@ function recordResume(plan: Launch): void {
  * Starts the child, then points the run lock at it and records the agent. A child that never started (no pid) has no
  * transcript and changes no record, so a new agent's ID never becomes resumable; a fork's copied transcript is removed with it.
  */
-function start(plan: Launch, prompt: string, signal: AbortSignal | undefined, lock: RunLock): ChildHandle {
+function start(plan: Launch, rawInput: ChildInput, signal: AbortSignal | undefined, lock: RunLock): ChildHandle {
   let handle: ChildHandle | undefined;
   try {
-    handle = launchChild(plan, plan.kind === 'fresh' && plan.worktree !== undefined ? worktreePreface(plan.worktree, prompt) : prompt, signal);
+    const input = plan.kind === 'fresh' && plan.worktree !== undefined ? { ...rawInput, text: worktreePreface(plan.worktree, rawInput.text) } : rawInput;
+    handle = launchChild(plan, input, signal);
     if (handle.pid !== undefined) {
       lock.holdFor(handle.pid);
       if (plan.kind === 'resume') recordResume(plan);
@@ -387,7 +382,7 @@ async function steerRunning(params: TaskInput, running: { handle: ChildHandle; r
   const agentId = params.resume ?? '';
   if ((params.readonly === true || planMode) && !running.readonly)
     throw new Error(`Agent ${agentId} is running with write access, so a readonly call cannot message it${planMode ? ' (plan mode makes every Task call readonly)' : ''}. Wait for its completion notification, or stop it with stop_agent.`);
-  const input = withAttachments(params.prompt, resolveAttachments(params.file_attachments ?? [], ctx.cwd));
+  const input = await withAttachments(params.prompt, resolveAttachments(params.file_attachments ?? [], ctx.cwd));
   await running.handle.steer(input.text, input.images).catch((error: Error) => {
     throw new Error(`Agent ${agentId} finished before the message reached it (${error.message}). Resume it once its result arrives.`);
   });
@@ -427,6 +422,7 @@ export interface TaskHandle {
 
 export function registerTask(pi: ExtensionAPI, options: TaskToolOptions): TaskHandle {
   const registry = createSubagentRegistry(pi);
+  pi.registerMessageRenderer?.(NOTIFICATION_TYPE, (message, renderOptions) => renderTaskNotification(message, renderOptions));
   let sessionCtx: ExtensionContext | undefined;
   pi.on('agent_before_settle', (event, ctx) => registry.beforeSettle(ctx, event.outcome));
   pi.on('session_shutdown', (event, ctx) => {
@@ -458,11 +454,12 @@ export function registerTask(pi: ExtensionAPI, options: TaskToolOptions): TaskHa
       taskPreflight(params, options.depth);
       const running = params.resume === undefined ? undefined : registry.get(validateAgentId(params.resume));
       if (running !== undefined) return steerRunning(params, running, ctx, options.planMode?.() === true);
+      const attachments = resolveAttachments(params.file_attachments ?? [], ctx.cwd);
+      const input = attachments.length === 0 ? { text: params.prompt.trim(), images: [] } : await withAttachments(params.prompt, attachments);
       const { plan, lock } = prepare(params, ctx, options, registry.isRunning);
-      // Awaiting yields to a parallel Task call, so only a fresh isolated agent awaits before it is tracked.
       if (plan.kind === 'fresh' && plan.worktree !== undefined) await createWorktree(plan, lock, signal);
       const background = params.run_in_background ?? plan.agent.background;
-      const handle = start(plan, params.prompt, background ? undefined : signal, lock);
+      const handle = start(plan, input, background ? undefined : signal, lock);
       if (background) {
         registry.track(plan.agentId, handle, lock.release, runsReadonly(plan), backgroundNotice(plan, params.prompt, ctx, toolCallId));
         return { content: [{ type: 'text', text: backgroundText(plan.agentId, transcriptOf(plan), plan.notes) }], details: details(plan, true, 'running', handle.pid) };
@@ -482,7 +479,7 @@ export function registerTask(pi: ExtensionAPI, options: TaskToolOptions): TaskHa
     taskPreflight(params, options.depth);
     const { plan, lock } = prepare(params, ctx, options, registry.isRunning);
     await createWorktree(plan, lock, undefined);
-    const handle = start(plan, prompt, undefined, lock);
+    const handle = start(plan, { text: prompt.trim(), images: [] }, undefined, lock);
     registry.track(plan.agentId, handle, lock.release, runsReadonly(plan), backgroundNotice(plan, prompt, ctx, `pstack-${plan.agentId}`));
     return plan.agentId;
   }

package/src/todo.ts

@@ -1,4 +1,3 @@
-import { StringEnum } from '@earendil-works/pi-ai';
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
 import { Type } from 'typebox';
 
@@ -30,7 +29,7 @@ const TodoParams = Type.Object({
     Type.Object({
       id: Type.String({ description: 'Unique identifier for the TODO item' }),
       content: Type.Optional(Type.String({ description: 'The description/content of the TODO item. Required for a new item; may be omitted when merging an update.' })),
-      status: Type.Optional(StringEnum(STATUSES, { description: 'The current status of the TODO item. Required for a new item; may be omitted when merging an update.' })),
+      status: Type.Optional(Type.Enum(STATUSES, { type: 'string', description: 'The current status of the TODO item. Required for a new item; may be omitted when merging an update.' })),
     }),
     { minItems: 1, description: 'Array of TODO items to update or create' },
   ),

package/scripts/live-e2e.mjs

@@ -1,257 +0,0 @@
-#!/usr/bin/env node
-// Runs pstack scenarios against a real model through the Pi CLI and records what the model did.
-// Usage: live-e2e.mjs [--model provider/id] [--scenario poteto|delegate|nocomments|setup|all] [--out <dir>] [--tag <name>]
-//                     [--rule <file>] [--providers claude-subscription]
-// --rule copies a pstack-models.md into the throwaway agent directory first, for example to bound subagent cost.
-// --providers loads extra provider packages so their models are available without driving the run.
-// It needs credentials in the user's Pi auth.json. Each scenario uses a throwaway workspace, HOME, and agent
-// directory, and auth.json is symlinked rather than copied. Pi writes refreshed OAuth tokens through that symlink,
-// so an OAuth refresh during a live run updates the user's real auth.json, and its lock file sits beside the
-// symlink rather than the real file; avoid running OAuth-provider scenarios while another Pi session refreshes.
-// The model under test has bash and write tools, so it could read or overwrite the real auth.json through that
-// symlink. Run it only with models and prompts you trust, and review the recorded tool calls in the evidence file.
-import { execFileSync, spawn } from 'node:child_process';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
-import { homedir, tmpdir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { resolveSubagentModel } from '../src/task/models.ts';
-
-const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-const repoRoot = resolve(packageRoot, '../..');
-const cli = join(packageRoot, 'node_modules/@earendil-works/pi-coding-agent/dist/bundle/cli.js');
-const userAgentDir = process.env.PI_CODING_AGENT_DIR ?? join(homedir(), '.pi/agent');
-const ROLES = [
-  'feature, refactoring',
-  'bug-fix',
-  'perf-issue',
-  'hillclimb',
-  'judgment and prose',
-  'hardest tasks',
-  'how explorer',
-  'how explainer',
-  'why investigators',
-  'why synthesizer',
-  'reflect tooling',
-  'reflect judgment, divergent, synthesizer',
-  'arena runners',
-  'arena cross-judge pool',
-  'swarm workers',
-  'architect runners',
-  'interrogate reviewers',
-];
-
-const PROVIDER_PACKAGES = { 'claude-subscription': 'extensions/pi-anthropic-oauth' };
-
-function sandbox(model, ruleFile, providers) {
-  const root = realpathSync(mkdtempSync(join(tmpdir(), 'pstack-live-')));
-  const agentDir = join(root, 'agent');
-  const work = join(root, 'work');
-  mkdirSync(agentDir);
-  mkdirSync(work);
-  mkdirSync(join(root, 'home'));
-  symlinkSync(join(userAgentDir, 'auth.json'), join(agentDir, 'auth.json'));
-  // Only the driver's provider loads, so default role models such as claude-opus-5-5-xhigh cannot bill a subscription unasked.
-  const wanted = new Set([model.split('/')[0], ...providers]);
-  const packages = [
-    packageRoot,
-    ...Object.entries(PROVIDER_PACKAGES)
-      .filter(([provider]) => wanted.has(provider))
-      .map(([, path]) => join(repoRoot, path)),
-  ];
-  writeFileSync(join(agentDir, 'settings.json'), JSON.stringify({ packages, quietStartup: true, defaultProvider: model.split('/')[0], defaultModel: model.split('/')[1] }));
-  if (ruleFile !== undefined) {
-    mkdirSync(join(agentDir, 'pstack'));
-    writeFileSync(join(agentDir, 'pstack/pstack-models.md'), readFileSync(ruleFile));
-  }
-  const git = (...args) => execFileSync('git', ['-C', work, ...args], { stdio: 'ignore' });
-  git('init', '-q', '-b', 'main');
-  return { root, agentDir, work, git, env: { ...process.env, HOME: join(root, 'home'), PI_CODING_AGENT_DIR: agentDir } };
-}
-
-function commitAll(box, message) {
-  box.git('add', '-A');
-  box.git('-c', 'user.email=live@example.com', '-c', 'user.name=live', 'commit', '-qm', message);
-}
-
-function runPi(box, model, prompt, timeoutMs) {
-  return new Promise((resolveRun) => {
-    const started = Date.now();
-    const child = spawn(process.execPath, [cli, '--mode', 'json', '--no-session', '--model', model, prompt], { cwd: box.work, env: box.env, stdio: ['ignore', 'pipe', 'pipe'] });
-    const events = [];
-    let buffer = '';
-    let stderr = '';
-    const timer = setTimeout(() => child.kill('SIGTERM'), timeoutMs);
-    child.stdout.on('data', (chunk) => {
-      buffer += chunk.toString('utf8');
-      for (let index = buffer.indexOf('\n'); index !== -1; index = buffer.indexOf('\n')) {
-        const line = buffer.slice(0, index).trim();
-        buffer = buffer.slice(index + 1);
-        if (line !== '') events.push(JSON.parse(line));
-      }
-    });
-    child.stderr.on('data', (chunk) => {
-      stderr += chunk.toString('utf8');
-    });
-    child.on('close', (code) => {
-      clearTimeout(timer);
-      resolveRun({ events, code, stderr: stderr.slice(-4000), seconds: Math.round((Date.now() - started) / 1000) });
-    });
-  });
-}
-
-function toolCalls(events) {
-  return events
-    .filter((event) => event.type === 'message_end' && event.message?.role === 'assistant')
-    .flatMap((event) => event.message.content.filter((part) => part.type === 'toolCall').map((part) => ({ name: part.name, arguments: part.arguments })));
-}
-
-function finalText(events) {
-  const last = events.filter((event) => event.type === 'message_end' && event.message?.role === 'assistant').at(-1);
-  return (last?.message.content ?? [])
-    .filter((part) => part.type === 'text')
-    .map((part) => part.text)
-    .join('')
-    .slice(0, 3000);
-}
-
-const playbookSteps = (name) =>
-  readFileSync(join(packageRoot, `skills/poteto-mode/playbooks/${name}.md`), 'utf8')
-    .split('\n')
-    .filter((line) => /^\d+\. /.test(line))
-    .map((line) => line.replace(/^\d+\. /, ''));
-
-const SCENARIOS = {
-  poteto: {
-    requirement: 'LIVE-001',
-    prompt: '/poteto-mode How does add in calc.js treat two numeric strings such as "2" and "3"? This is a read-only question; do not change any files.',
-    prepare: (box) => {
-      writeFileSync(join(box.work, 'calc.js'), 'export function add(a, b) {\n  return a + b;\n}\n');
-      commitAll(box, 'calc');
-    },
-    check: (calls, box) => {
-      const steps = playbookSteps('investigation');
-      const playbook = 'poteto-mode/playbooks/investigation.md';
-      const readPlaybook = calls.some((call) => (call.name === 'read' && String(call.arguments.path ?? '').endsWith(playbook)) || (call.name === 'bash' && String(call.arguments.command ?? '').includes(playbook)));
-      const todos = calls.find((call) => call.name === 'TodoWrite')?.arguments.todos ?? [];
-      // A todo list is plain text, so Markdown emphasis marks (** and backticks) are dropped before comparing.
-      const plain = (text) => text.replace(/\*\*|`/g, '');
-      const verbatim = steps.map((step, index) => typeof todos[index]?.content === 'string' && plain(todos[index].content) === plain(step));
-      const clean = execFileSync('git', ['-C', box.work, 'status', '--porcelain'], { encoding: 'utf8' }).trim() === '';
-      return { readPlaybook, firstTodosAreStepsVerbatim: verbatim.every(Boolean), stepMatches: verbatim, workspaceUnchanged: clean, todos: todos.map((todo) => todo.content) };
-    },
-  },
-  delegate: {
-    requirement: 'LIVE-004',
-    prompt: '/poteto-mode Delegate to one foreground poteto-agent: find what calc.js exports. Read-only.',
-    prepare: (box) => {
-      writeFileSync(join(box.work, 'calc.js'), 'export const add = (a, b) => a + b;\n');
-      commitAll(box, 'calc');
-    },
-    check: (calls) => {
-      // pstack 0.15.21: the parent puts poteto-mode's absolute SKILL.md path in every poteto-agent prompt.
-      const skillPath = join(packageRoot, 'skills/poteto-mode/SKILL.md');
-      const delegates = calls.filter((call) => call.name === 'Task' && call.arguments.subagent_type === 'poteto-agent');
-      return {
-        delegated: delegates.length > 0,
-        everyPromptHasSkillPath: delegates.length > 0 && delegates.every((call) => String(call.arguments.prompt ?? '').includes(skillPath)),
-        prompts: delegates.map((call) => String(call.arguments.prompt ?? '').slice(0, 400)),
-      };
-    },
-  },
-  nocomments: {
-    requirement: 'LIVE-002',
-    prompt: '/no-comments',
-    prepare: (box) => {
-      writeFileSync(join(box.work, 'util.js'), 'export function add(a, b) {\n  return a + b;\n}\n');
-      commitAll(box, 'util');
-      writeFileSync(join(box.work, 'util.js'), '// This function adds two numbers together\nexport function add(a, b) {\n  // return the sum of a and b\n  return a + b;\n}\n');
-    },
-    check: (calls) => {
-      const tasks = calls.filter((call) => call.name === 'Task');
-      return { spawnedCommentSicko: tasks.some((call) => call.arguments.subagent_type === 'comment-sicko'), taskTypes: tasks.map((call) => call.arguments.subagent_type ?? '(default)') };
-    },
-  },
-  setup: {
-    requirement: 'LIVE-003',
-    prompt:
-      "/setup-pstack Use the large budget and keep the skill's mapping. For a role whose default model is not available, use the closest available model of the same family, else inherit-parent. Do not ask me anything; write the rule now.",
-    prepare: () => undefined,
-    check: (_calls, box, model) => {
-      const rule = join(box.agentDir, 'pstack/pstack-models.md');
-      const text = existsSync(rule) ? readFileSync(rule, 'utf8') : '';
-      const missing = ROLES.filter((role) => !text.split('\n').some((line) => line.startsWith(`${role}:`)));
-      const values = text
-        .split('\n')
-        .filter((line) => ROLES.some((role) => line.startsWith(`${role}:`)))
-        .flatMap((line) => line.slice(line.indexOf(':') + 1).split(','))
-        .map((value) => value.trim());
-      const available = listModels(box);
-      const parent = { provider: model.split('/')[0], id: model.split('/')[1] };
-      const unresolved = values.filter((value) => {
-        try {
-          resolveSubagentModel(value, available, parent);
-          return false;
-        } catch {
-          return true;
-        }
-      });
-      return {
-        ruleWritten: text !== '',
-        noFrontmatter: !text.startsWith('---'),
-        missingRoles: missing,
-        distinctValues: [...new Set(values)],
-        unresolvedValues: unresolved,
-        rule: text,
-      };
-    },
-  },
-};
-
-/** The models the throwaway agent directory exposes, with the thinking levels Pi supports for each, as Task sees them. */
-function listModels(box) {
-  const fixture = join(packageRoot, 'test/fixtures/list-models.ts');
-  const output = execFileSync(process.execPath, [cli, '-p', '--offline', '--no-session', '-e', fixture, '/list-models'], { cwd: box.work, env: box.env, encoding: 'utf8' });
-  return output
-    .split('\n')
-    .filter((line) => line.startsWith('{'))
-    .map((line) => JSON.parse(line));
-}
-
-async function runScenario(name, model, outDir, tag, ruleFile, providers) {
-  const scenario = SCENARIOS[name];
-  const box = sandbox(model, ruleFile, providers);
-  try {
-    scenario.prepare(box);
-    const run = await runPi(box, model, scenario.prompt, 15 * 60_000);
-    const calls = toolCalls(run.events);
-    const result = {
-      scenario: name,
-      requirement: scenario.requirement,
-      model,
-      prompt: scenario.prompt,
-      exitCode: run.code,
-      seconds: run.seconds,
-      checks: scenario.check(calls, box, model),
-      toolCalls: calls.map((call) => ({ name: call.name, arguments: JSON.stringify(call.arguments).slice(0, 600) })),
-      finalText: finalText(run.events),
-      stderrTail: run.stderr,
-    };
-    writeFileSync(join(outDir, `live-${name}${tag === undefined ? '' : `-${tag}`}.json`), `${JSON.stringify(result, null, 2)}\n`);
-    process.stdout.write(`${name}: ${JSON.stringify(result.checks)}\n`);
-  } finally {
-    rmSync(box.root, { recursive: true, force: true });
-  }
-}
-
-const argv = process.argv.slice(2);
-const option = (name, fallback) => (argv.includes(name) ? argv[argv.indexOf(name) + 1] : fallback);
-const model = option('--model', 'deepseek/deepseek-flash');
-const outDir = resolve(option('--out', join(repoRoot, 'parity/pi-pstack-two/evidence')));
-const chosen = option('--scenario', 'all');
-const tag = option('--tag', undefined);
-const ruleFile = argv.includes('--rule') ? resolve(option('--rule', '')) : undefined;
-const providers = option('--providers', '').split(',').filter(Boolean);
-mkdirSync(outDir, { recursive: true });
-for (const name of chosen === 'all' ? Object.keys(SCENARIOS) : [chosen]) await runScenario(name, model, outDir, tag, ruleFile, providers);

package/test/aliases.test.ts

@@ -1,57 +0,0 @@
-import { join } from 'node:path';
-
-import { describe, expect, test } from 'vitest';
-import { aliasInputResult, aliasTable, aliasTransform, packageSkillNames } from '../src/aliases.ts';
-import { SKILLS_DIR } from '../src/paths.ts';
-
-const names = new Set(['how', 'poteto-mode', 'principle-prove-it-works']);
-
-describe('aliasTransform', () => {
-  test.for([
-    { input: '/how', expected: '/skill:how' },
-    { input: '/how does the cache work?', expected: '/skill:how does the cache work?' },
-    { input: '/poteto-mode fix the "drift" bug\nrepro first, then $1 and $@', expected: '/skill:poteto-mode fix the "drift" bug\nrepro first, then $1 and $@' },
-    { input: '/how\nwhat owns retries?', expected: '/skill:how \nwhat owns retries?' },
-    { input: '/principle-prove-it-works', expected: '/skill:principle-prove-it-works' },
-  ])('rewrites $input to a native skill command (CMD-001)', ({ input, expected }) => {
-    expect(aliasTransform(input, names)).toBe(expected);
-  });
-
-  test.for([
-    { input: '/skill:how what', why: 'already native' },
-    { input: '/model', why: 'a Pi built-in' },
-    { input: '/howdy partner', why: 'a longer word that only starts with a skill name' },
-    { input: '/unknown thing', why: 'not a shipped skill' },
-    { input: 'please /how this', why: 'not at the start' },
-    { input: ' /how leading space', why: 'Pi commands start at column zero' },
-    { input: '', why: 'empty input' },
-  ])('leaves $why input alone (CMD-002)', ({ input }) => {
-    expect(aliasInputResult({ text: input }, names)).toEqual({ action: 'continue' });
-  });
-
-  test('the input handler transforms an alias and keeps attached images (CMD-001)', () => {
-    const images = [{ type: 'image' as const, data: 'AAAA', mimeType: 'image/png' }];
-    expect(aliasInputResult({ text: '/how this screen?', images }, names)).toEqual({ action: 'transform', text: '/skill:how this screen?', images });
-  });
-});
-
-describe('aliasTable (CMD-002, CMD-003; review: architecture 6)', () => {
-  const skill = (name: string, path: string) => ({ name: `skill:${name}`, description: `${name} skill`, source: 'skill' as const, sourceInfo: { path, source: 'test', scope: 'user' as const, origin: 'package' as const } });
-  const commands = [
-    skill('how', join(SKILLS_DIR, 'how/SKILL.md')),
-    skill('why', join(SKILLS_DIR, 'why/SKILL.md')),
-    skill('mine', '/home/me/.pi/agent/skills/mine/SKILL.md'),
-    { name: 'why', description: 'user template', source: 'prompt' as const, sourceInfo: { path: '/home/me/.pi/agent/prompts/why.md', source: 'test', scope: 'user' as const, origin: 'top-level' as const } },
-  ];
-
-  test('aliases every loaded skill that no template or command already names, as Cursor attaches any skill by /name (review r2: parity 1)', () => {
-    expect([...aliasTable(commands)]).toEqual([
-      ['how', 'how skill'],
-      ['mine', 'mine skill'],
-    ]);
-  });
-
-  test('lists the loaded skills that live in this package, by canonical path (A4, recheck 1)', () => {
-    expect(packageSkillNames(commands)).toEqual(['how', 'why']);
-  });
-});

package/test/ask.test.ts

@@ -1,85 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import type { Static } from 'typebox';
-import { Value } from 'typebox/value';
-import { describe, expect, test } from 'vitest';
-import { AskParams, DONE_LABEL, validateQuestions } from '../src/ask.ts';
-
-const question = (options: { id: string; label: string }[], allow_multiple?: boolean) => ({ id: 'q', prompt: 'Pick', options, ...(allow_multiple === undefined ? {} : { allow_multiple }) });
-const outcome = (questions: ReturnType<typeof question>[]) => {
-  try {
-    validateQuestions(questions);
-    return 'valid';
-  } catch (error) {
-    return (error as Error).message;
-  }
-};
-
-describe('validateQuestions (HOST-005; reviews: parity, security 6, architecture 4)', () => {
-  test.for([
-    {
-      name: 'duplicate labels',
-      questions: [
-        question([
-          { id: 'a', label: 'Same' },
-          { id: 'b', label: 'Same' },
-        ]),
-      ],
-      expected: 'Question "q" has two options labelled "Same".',
-    },
-    {
-      name: 'duplicate option ids',
-      questions: [
-        question([
-          { id: 'a', label: 'A' },
-          { id: 'a', label: 'B' },
-        ]),
-      ],
-      expected: 'Question "q" has two options with id "a".',
-    },
-    { name: 'no options', questions: [question([])], expected: 'Question "q" has no options.' },
-    { name: 'the reserved other id', questions: [question([{ id: 'other', label: 'Something else' }])], expected: 'Option label "Other: (type to answer)" and id "other" are reserved for the typed answer.' },
-    { name: 'the reserved done label', questions: [question([{ id: 'd', label: DONE_LABEL }], true)], expected: `Option label "${DONE_LABEL}" is reserved for ending a multi-select question.` },
-    {
-      name: 'a well-formed question',
-      questions: [
-        question(
-          [
-            { id: 'a', label: 'Done' },
-            { id: 'b', label: 'B' },
-          ],
-          true,
-        ),
-      ],
-      expected: 'valid',
-    },
-  ])('$name', ({ questions, expected }) => {
-    expect(outcome(questions)).toBe(expected);
-  });
-});
-
-describe('Cursor AskQuestion calls (HOST-005)', () => {
-  // 24 AskQuestion inputs the Cursor IDE produced, read from its agent transcripts.
-  const fixture = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), 'fixtures/cursor-askquestion-calls.json'), 'utf8')) as { calls: { input: Static<typeof AskParams> }[] };
-  const questionSchema = AskParams.properties.questions.items;
-  const optionSchema = questionSchema.properties.options.items;
-
-  test('every field Cursor sends is declared by the port schema', () => {
-    const undeclared = fixture.calls.flatMap(({ input }) => [
-      ...Object.keys(input).filter((key) => !(key in AskParams.properties)),
-      ...input.questions.flatMap((question) => [
-        ...Object.keys(question).filter((key) => !(key in questionSchema.properties)),
-        ...question.options.flatMap((option) => Object.keys(option).filter((key) => !(key in optionSchema.properties))),
-      ]),
-    ]);
-    expect(fixture.calls.length).toBe(24);
-    expect(undeclared).toEqual([]);
-  });
-
-  test('every Cursor call is valid input for the port', () => {
-    expect(fixture.calls.filter(({ input }) => !Value.Check(AskParams, input))).toEqual([]);
-    expect(fixture.calls.map(({ input }) => outcome(input.questions as ReturnType<typeof question>[]))).toEqual(fixture.calls.map(() => 'valid'));
-  });
-});

package/test/autocomplete.test.ts

@@ -1,39 +0,0 @@
-import type { AutocompleteItem, AutocompleteProvider } from '@earendil-works/pi-tui';
-import { describe, expect, test } from 'vitest';
-import { aliasAutocomplete } from '../src/autocomplete.ts';
-
-const builtin: AutocompleteItem[] = [
-  { value: 'skill:poteto-mode', label: 'skill:poteto-mode' },
-  { value: 'model', label: 'model' },
-];
-const current: AutocompleteProvider = {
-  getSuggestions: async (lines, _line, col) => ((lines[0] ?? '').slice(0, col).startsWith('/') ? { items: builtin, prefix: (lines[0] ?? '').slice(0, col) } : null),
-  applyCompletion: (lines, cursorLine, _col, item, prefix) => ({ lines: [`/${item.value} `, ...lines.slice(1)], cursorLine, cursorCol: prefix.length }),
-};
-const aliases = new Map([
-  ['poteto-mode', "poteto's agent style"],
-  ['poteto-help', 'Guides users through pstack'],
-  ['how', 'Explains how code works'],
-]);
-const signal = new AbortController().signal;
-
-describe('alias autocomplete (CMD-003)', () => {
-  test('lists matching pstack skills under their Cursor names ahead of the built-in suggestions', async () => {
-    const provider = aliasAutocomplete(current, aliases);
-    expect(await provider.getSuggestions(['/pot'], 0, 4, { signal })).toEqual({
-      prefix: '/pot',
-      items: [{ value: 'poteto-mode', label: 'poteto-mode', description: "poteto's agent style" }, { value: 'poteto-help', label: 'poteto-help', description: 'Guides users through pstack' }, ...builtin],
-    });
-  });
-
-  test('leaves completions alone outside a leading command token', async () => {
-    const provider = aliasAutocomplete(current, aliases);
-    expect(await provider.getSuggestions(['/how why'], 0, 8, { signal })).toEqual({ items: builtin, prefix: '/how why' });
-    expect(await provider.getSuggestions(['say /pot'], 0, 8, { signal })).toEqual(null);
-  });
-
-  test('applies an alias like any command completion', () => {
-    const provider = aliasAutocomplete(current, aliases);
-    expect(provider.applyCompletion(['/pot'], 0, 4, { value: 'poteto-mode', label: 'poteto-mode' }, '/pot')).toEqual({ lines: ['/poteto-mode '], cursorLine: 0, cursorCol: 4 });
-  });
-});