mixdog 0.9.152 → 0.9.154

package/src/session-runtime/skills-api.test.mjs

@@ -1,99 +0,0 @@
-import assert from 'node:assert/strict';
-import {
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import test from 'node:test';
-
-import * as contextMod from '../runtime/agent/orchestrator/context/collect.mjs';
-import { parseSkillDocument } from '../runtime/shared/skill-document.mjs';
-import { createSkillsApi } from './skills-api.mjs';
-
-test('edits existing skills without dropping optional metadata or sibling resources', () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-skill-edit-'));
-  const previousDataDir = process.env.MIXDOG_DATA_DIR;
-  process.env.MIXDOG_DATA_DIR = join(root, 'data');
-  try {
-    const cwd = join(root, 'project');
-    const originalDir = join(process.env.MIXDOG_DATA_DIR, 'skills', 'existing-skill');
-    mkdirSync(join(originalDir, 'scripts'), { recursive: true });
-    writeFileSync(join(originalDir, 'SKILL.md'), [
-      '---',
-      'name: existing-skill',
-      'description: Use when editing an existing skill.',
-      'license: MIT',
-      'metadata:',
-      '  author: example',
-      'allowed-tools:',
-      '  - shell',
-      '---',
-      '',
-      '# Original instructions',
-      '',
-    ].join('\n'));
-    writeFileSync(join(originalDir, 'scripts', 'check.py'), 'print("ok")\n');
-
-    const api = createSkillsApi({ contextMod, getCwd: () => cwd });
-    const saved = api.saveSkillDocument({
-      originalName: 'existing-skill',
-      name: 'renamed-skill',
-      description: 'Use when the renamed skill is needed.',
-      instructions: '# Updated instructions',
-    });
-    const renamedDir = join(process.env.MIXDOG_DATA_DIR, 'skills', 'renamed-skill');
-    const parsed = parseSkillDocument(readFileSync(saved.filePath, 'utf8'));
-
-    assert.equal(existsSync(originalDir), false);
-    assert.equal(saved.filePath, join(renamedDir, 'SKILL.md'));
-    assert.equal(existsSync(join(renamedDir, 'scripts', 'check.py')), true);
-    assert.equal(parsed.name, 'renamed-skill');
-    assert.equal(parsed.description, 'Use when the renamed skill is needed.');
-    assert.equal(parsed.body, '# Updated instructions\n');
-    assert.equal(parsed.frontmatter.license, 'MIT');
-    assert.deepEqual(parsed.frontmatter.metadata, { author: 'example' });
-    assert.deepEqual(parsed.frontmatter['allowed-tools'], ['shell']);
-    assert.ok(api.skillsStatus().skills.some((skill) => skill.name === 'renamed-skill'));
-  } finally {
-    contextMod.invalidateSkillsCache(join(root, 'project'));
-    if (previousDataDir === undefined) delete process.env.MIXDOG_DATA_DIR;
-    else process.env.MIXDOG_DATA_DIR = previousDataDir;
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('creates new global skills with all three standard fields', () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-skill-create-'));
-  const previousDataDir = process.env.MIXDOG_DATA_DIR;
-  process.env.MIXDOG_DATA_DIR = join(root, 'data');
-  try {
-    const cwd = join(root, 'project');
-    const api = createSkillsApi({ contextMod, getCwd: () => cwd });
-    const created = api.addGlobalSkill({
-      name: 'new-skill',
-      description: 'Use when creating a standard skill.',
-      instructions: '# Instructions\n\nDo the work.',
-    });
-    const parsed = parseSkillDocument(readFileSync(created.filePath, 'utf8'));
-
-    assert.equal(parsed.name, 'new-skill');
-    assert.equal(parsed.description, 'Use when creating a standard skill.');
-    assert.equal(parsed.body, '# Instructions\n\nDo the work.\n');
-    assert.equal(created.filePath, join(process.env.MIXDOG_DATA_DIR, 'skills', 'new-skill', 'SKILL.md'));
-    assert.throws(() => api.addGlobalSkill({
-      name: 'Invalid_Name',
-      description: 'Use when invalid.',
-      instructions: '# Instructions',
-    }), /lowercase letters/);
-  } finally {
-    contextMod.invalidateSkillsCache(join(root, 'project'));
-    if (previousDataDir === undefined) delete process.env.MIXDOG_DATA_DIR;
-    else process.env.MIXDOG_DATA_DIR = previousDataDir;
-    rmSync(root, { recursive: true, force: true });
-  }
-});

package/src/session-runtime/tool-policy-surface.test.mjs

@@ -1,331 +0,0 @@
-import assert from 'node:assert/strict';
-import { createRequire } from 'node:module';
-import { test } from 'node:test';
-import { join } from 'node:path';
-import { createToolSurface } from './tool-surface.mjs';
-import { createToolPolicyRefresh } from './tool-policy-refresh.mjs';
-import { toSessionWorkflowMeta, workflowDisallowsAgentTool } from './workflow.mjs';
-import { PATCH_TOOL_DEFS } from '../runtime/agent/orchestrator/tools/patch-tool-defs.mjs';
-import { DEFERRED_DEFAULT_LEAD_TOOLS } from './tool-catalog-data.mjs';
-
-const require = createRequire(import.meta.url);
-const { omitToolRoutes, buildSharedToolContent, buildAgentRoleContent } = require('../lib/rules-builder.cjs');
-
-// Tool dependency is declared by `<!-- tools: … -->` markers, so this fixture
-// carries the markers rather than prose the builder would have to match.
-const SAMPLE_ROUTES = [
-  '<!-- tools: web_search, web_fetch -->',
-  '# Research',
-  '',
-  '<!-- tools: web_search, web_fetch -->',
-  '- Research routes:',
-  '<!-- tools: web_search -->',
-  '  current or external information discovery→`web_search`;',
-  '<!-- tools: web_fetch -->',
-  '  page or documentation body retrieval from a known URL→`web_fetch`.',
-  '<!-- tools: recall, memory -->',
-  '# Memory',
-  '',
-  '<!-- tools: recall -->',
-  '- past facts recorded in prior work or sessions→`recall`',
-  '  (stored history only, never current local state).',
-  '<!-- tools: memory -->',
-  '- Durable memory creation or update→`memory`; store a compact English',
-  '  statement.',
-  '<!-- tools: memory -->',
-  '- Use judgment to decide whether a durable memory should be stored.',
-].join('\n');
-
-test('omitToolRoutes strips markers and keeps every clause when nothing is omitted', () => {
-  const kept = omitToolRoutes(SAMPLE_ROUTES, []);
-  assert.equal(kept.includes('<!--'), false);
-  assert.equal(kept.includes('`web_search`'), true);
-  assert.equal(kept.includes('`web_fetch`'), true);
-  assert.equal(kept.includes('`recall`'), true);
-  assert.equal(kept.includes('`memory`'), true);
-  assert.equal(kept.includes('# Research'), true);
-  assert.equal(kept.includes('# Memory'), true);
-  // The continuation line stays attached to the clause it belongs to.
-  assert.match(kept, /→`recall`\n\s+\(stored history only, never current local state\)\./);
-});
-
-test('omitToolRoutes drops a clause only when every tool it declares is omitted', () => {
-  const noSearchOnly = omitToolRoutes(SAMPLE_ROUTES, ['web_search']);
-  assert.equal(noSearchOnly.includes('`web_search`'), false);
-  assert.equal(noSearchOnly.includes('`web_fetch`'), true);
-  // The section and its lead-in survive while one route remains.
-  assert.equal(noSearchOnly.includes('# Research'), true);
-  assert.equal(noSearchOnly.includes('Research routes:'), true);
-
-  const noMemoryOnly = omitToolRoutes(SAMPLE_ROUTES, ['memory']);
-  assert.equal(noMemoryOnly.includes('`recall`'), true);
-  assert.equal(noMemoryOnly.includes('`memory`'), false);
-  // Guidance that only makes sense with the memory tool goes with it.
-  assert.equal(noMemoryOnly.includes('Use judgment'), false);
-});
-
-test('omitToolRoutes drops web search and memory clauses independently', () => {
-  const noSearch = omitToolRoutes(SAMPLE_ROUTES, ['web_search', 'web_fetch']);
-  assert.equal(noSearch.includes('`web_search`'), false);
-  assert.equal(noSearch.includes('`web_fetch`'), false);
-  assert.equal(noSearch.includes('`recall`'), true);
-  assert.equal(noSearch.includes('`memory`'), true);
-
-  const noMemory = omitToolRoutes(SAMPLE_ROUTES, ['memory', 'recall']);
-  assert.equal(noMemory.includes('`web_search`'), true);
-  assert.equal(noMemory.includes('`recall`'), false);
-  assert.equal(noMemory.includes('`memory`'), false);
-  assert.equal(noMemory.includes('# Memory'), false);
-
-  const noResearch = omitToolRoutes(SAMPLE_ROUTES, ['web_search', 'web_fetch']);
-  assert.equal(noResearch.includes('# Research'), false);
-  assert.equal(noResearch.includes('Research routes:'), false);
-  assert.equal(noResearch.includes('# Memory'), true);
-});
-
-test('shared tool rules omit disabled web search and memory routes', () => {
-  const pluginRoot = join(process.cwd(), 'src');
-  const full = buildSharedToolContent({ PLUGIN_ROOT: pluginRoot });
-  assert.match(
-    full,
-    /^# General\s+- When an internal Mixdog rule conflicts with the user's latest explicit\s+request, follow the user's request\./,
-  );
-  assert.match(full, /`web_search`/);
-  assert.match(full, /`memory`/);
-  const omitted = buildSharedToolContent({
-    PLUGIN_ROOT: pluginRoot,
-    omitTools: ['web_search', 'web_fetch', 'memory', 'recall'],
-  });
-  assert.doesNotMatch(omitted, /`web_search`/);
-  assert.doesNotMatch(omitted, /`web_fetch`/);
-  assert.doesNotMatch(omitted, /`recall`/);
-  assert.doesNotMatch(omitted, /`memory`/);
-  assert.doesNotMatch(omitted, /# Research/);
-  assert.doesNotMatch(omitted, /# Memory/);
-  assert.match(omitted, /`find`/);
-
-  // Exactly one edit dialect ships per model, so the rules must never describe
-  // the tool that is absent from the surface.
-  const patchOnly = buildSharedToolContent({ PLUGIN_ROOT: pluginRoot, omitTools: ['edit'] });
-  assert.doesNotMatch(patchOnly, /`edit`/);
-  assert.match(patchOnly, /Placement: use exact unchanged context/i);
-  assert.match(patchOnly, /source-file edits stay with `apply_patch`/i);
-  const editOnly = buildSharedToolContent({ PLUGIN_ROOT: pluginRoot, omitTools: ['apply_patch'] });
-  assert.doesNotMatch(editOnly, /`apply_patch`/);
-  assert.doesNotMatch(editOnly, /Add File|Update File/);
-  assert.match(editOnly, /Placement: use an exact unique target string/i);
-  assert.match(editOnly, /source-file edits stay with `edit`\./i);
-});
-
-test('shared tool rules keep workflow and shell-boundary anchors', () => {
-  // Advisory drift check: update these anchors when the rule text
-  // intentionally changes.
-  const full = buildSharedToolContent({ PLUGIN_ROOT: join(process.cwd(), 'src') });
-  assert.match(full, /Determine the required outcome and missing evidence/i);
-  assert.match(full, /Before exploration or implementation, consult prior work, current external\s+information, or repository state only when needed/i);
-  assert.match(full, /Minimize tool turns by batching only calls that are independently necessary/i);
-  assert.match(full, /A call whose necessity or scope can change after\s+another result waits for that result/i);
-  assert.match(full, /Respect tool\/schema limits, never omit required fanout/i);
-  assert.match(full, /A check runs at the strictness the task requires; never raise a tool's own\s+severity beyond it/i);
-  assert.match(full, /Route each evidence facet once to its primary owner/i);
-  assert.match(full, /A summary,\s+overview, or enumeration is not a prerequisite to an operation whose complete\s+inputs are already known/i);
-  assert.match(full, /apply one analysis\s+to many targets as one parameterized call/i);
-  assert.match(full, /Evidence or artifacts available only through program execution, calculation,\s+data transformation, generated output, or unsupported-format decoding→`shell`/i);
-  assert.match(full, /an already-open shell is never a routing reason/i);
-  assert.match(full, /Route the missing evidence to its primary owner/i);
-  assert.match(full, /repository state, history, or diff→`git`/i);
-  assert.match(full, /Ownership is exclusive: each evidence type has one owner/i);
-  assert.match(full, /a\s+successful owner result closes that facet/i);
-  assert.match(full, /Blocking checks cover only essential integrity, security, compatibility, and\s+buildability invariants/i);
-  assert.match(full, /environment variable or the home directory are\s+resolved locations/i);
-  assert.match(full, /Use read-only means for inspection; never mutate to clear an obstacle or\s+unexpected state/i);
-  assert.match(full, /literal, regex, or text location→`grep`;\s+known-file content, range, or image→`read`/i);
-  assert.match(full, /is never re-found, re-derived, or\s+re-verified at any granularity/i);
-  assert.match(full, /Mine each returned result fully before opening the next round/i);
-  assert.match(full, /Stop exploring once sufficient evidence determines the next action required\s+by the request/i);
-  assert.match(full, /Enter Verification only after all planned work is complete/i);
-  assert.match(full, /Use an umbrella suite only when explicitly requested or required by the\s+documented project or release process/i);
-  assert.match(full, /If verification fails, collect all failures, leave Verification/i);
-  assert.match(full, /A successful verification closes the task unless later changes affect it/i);
-  assert.doesNotMatch(full, /affected failed checks once/i);
-  assert.match(full, /Every Git operation→`git`; source-file edits stay with `edit`\./i);
-  assert.match(full, /Every Git operation→`git`; source-file edits stay with `apply_patch`\./i);
-  assert.doesNotMatch(full, /Every repository mutation→`git`/i);
-  assert.doesNotMatch(full, /always batch safely in parallel/i);
-  assert.match(full, /A required new file is created directly: Add File is itself the atomic\s+absence check/i);
-  assert.match(full, /Source: use exact current target text from any visible evidence/i);
-  assert.match(full, /Placement: use an exact unique target string/i);
-  assert.match(full, /Placement: use exact unchanged context/i);
-  assert.match(full, /Apply all determined changes in the fewest safe calls the active tool\s+supports/i);
-  assert.match(full, /One file, several changes: one Update File block carries every hunk/i);
-  assert.match(full, /One file, several changes: issue the calls together in one turn/i);
-  assert.match(full, /Defer only ambiguous or result-dependent changes/i);
-  assert.match(full, /Commit, push, release, and deployment happen only on the user's explicit\s+request/i);
-  assert.match(full, /past facts recorded in prior work or sessions→`recall`/i);
-  assert.match(full, /Use judgment to decide whether a durable memory should be stored/i);
-  assert.match(full, /Omit `project_id` for the current Project, use `"common"` for shared memory/i);
-  const headings = ['# General', '# Tool Workflow', '# Research', '# Exploration', '# Editing', '# Execution', '# Verification', '# Delivery', '# Memory'];
-  assert.deepEqual(headings.map((heading) => full.indexOf(heading)), headings.map((heading) => full.indexOf(heading)).toSorted((a, b) => a - b));
-  assert.ok(DEFERRED_DEFAULT_LEAD_TOOLS.includes('git'));
-  assert.equal(DEFERRED_DEFAULT_LEAD_TOOLS.includes('git_stage'), false);
-});
-
-test('agent git policy allows repository evidence but keeps mutations Lead-only', () => {
-  const rules = buildAgentRoleContent({ PLUGIN_ROOT: join(process.cwd(), 'src') });
-  assert.match(rules, /Use `git` only for read-only repository evidence/i);
-  assert.match(rules, /Refuse Git mutations\s+including `add`\/`commit`\/`push`\/`stash`/i);
-  assert.doesNotMatch(rules, /Never touch git/i);
-});
-
-test('apply_patch keeps grammar and mutation behavior on the freeform surface', () => {
-  const applyPatch = PATCH_TOOL_DEFS.find((tool) => tool.name === 'apply_patch');
-  assert.match(applyPatch.freeformDescription, /Add File atomically creates the file and missing parent directories/i);
-  assert.match(applyPatch.freeformDescription, /failing without changes if the target already exists/i);
-  assert.match(applyPatch.freeformDescription, /one Add\/Delete\/Update File block per target path/i);
-  assert.match(applyPatch.freeformDescription, /Multi-file patches commit valid files and report rejected files separately/i);
-  assert.equal(applyPatch.inputSchema.properties.patch.minLength, 1);
-});
-
-test('toSessionWorkflowMeta keeps delegatesAgents for Solo packs', () => {
-  const meta = toSessionWorkflowMeta({
-    id: 'solo',
-    name: 'Solo',
-    description: 'Lead works alone.',
-    source: 'built-in',
-    delegatesAgents: false,
-  });
-  assert.equal(meta.delegatesAgents, false);
-  assert.equal(workflowDisallowsAgentTool(meta), true);
-  assert.equal(workflowDisallowsAgentTool({ id: 'solo' }), false);
-});
-
-function surfaceFor({ session = null, denied = [], standalone = [] } = {}) {
-  return createToolSurface({
-    mgr: { previewSessionTools: () => standalone },
-    mode: 'full',
-    standaloneTools: standalone,
-    agentToolNames: new Set(['agent']),
-    getSession: () => session,
-    getRoute: () => ({ provider: 'grok-oauth' }),
-    getConfig: () => ({ workflow: { active: 'solo' } }),
-    cfgMod: { getPluginData: () => '' },
-    loadWorkflowPack: () => ({ id: 'solo', delegatesAgents: false }),
-    activeWorkflowId: () => 'solo',
-    dataDir: '',
-    getFeatureDisallowedTools: () => denied,
-  });
-}
-
-test('modelStandaloneTools hides agent and disabled web-search/memory tools', () => {
-  const standalone = [
-    { name: 'read' },
-    { name: 'agent' },
-    { name: 'web_search' },
-    { name: 'web_fetch' },
-    { name: 'memory' },
-    { name: 'recall' },
-  ];
-  const { modelStandaloneTools } = surfaceFor({
-    session: { workflow: { id: 'solo', delegatesAgents: false } },
-    denied: ['web_search', 'web_fetch', 'memory', 'recall'],
-    standalone,
-  });
-  assert.deepEqual(modelStandaloneTools().map((tool) => tool.name), ['read']);
-});
-
-test('activateTools refreshes a stale session catalog before selecting new runtime tools', () => {
-  const read = { name: 'read', annotations: { readOnlyHint: true } };
-  const updateGoal = { name: 'update_goal', annotations: { readOnlyHint: false } };
-  const session = {
-    provider: 'grok-oauth',
-    messages: [{ role: 'system', content: '# Existing session' }],
-    tools: [read],
-    deferredToolCatalog: [read],
-    deferredCallableTools: ['read'],
-    deferredSelectedTools: ['read'],
-    deferredToolBp2Applied: true,
-  };
-  const surface = surfaceFor({ session, standalone: [read, updateGoal] });
-  const result = surface.activateTools(['update_goal']);
-  assert.deepEqual(result.missing, []);
-  assert.equal(
-    new Set([
-      ...session.tools.map((tool) => tool.name),
-      ...(session.deferredCallableTools || []),
-    ]).has('update_goal'),
-    true,
-  );
-});
-
-test('empty session refresh strips denied tools and BP1 routes', async () => {
-  const session = {
-    id: 'sess_empty',
-    messages: [
-      { role: 'system', content: '# Tool Use\nweb/current→`web_search`; returned URL body→`web_fetch`;\nprior work→`recall` (history only, never current local state);\ndurable compact English memory→`memory`;\n' },
-      { role: 'system', content: '# Profile' },
-      { role: 'system', content: '# Active Workflow: Cowork\n\n---\n\n# Lead Tools\n', cacheTier: 'tier3' },
-    ],
-    tools: [{ name: 'read' }, { name: 'agent' }, { name: 'web_search' }, { name: 'memory' }],
-    deferredToolCatalog: [{ name: 'read' }, { name: 'agent' }, { name: 'web_search' }, { name: 'memory' }],
-    deferredCallableTools: ['read', 'agent', 'web_search', 'memory'],
-    workflow: { id: 'default', delegatesAgents: true },
-    bp3EnvironmentContext: '- Shell: PowerShell.',
-  };
-  const { refreshEmptySessionToolPolicy } = createToolPolicyRefresh({
-    getSession: () => session,
-    getRoute: () => ({ provider: 'grok-oauth' }),
-    getMode: () => 'full',
-    getConfig: () => ({ workflow: { active: 'solo' } }),
-    getDataDir: () => '',
-    modelStandaloneTools: () => [{ name: 'read' }],
-    featureDisallowedTools: () => ['web_search', 'web_fetch', 'memory', 'recall'],
-    memoryToolsEnabled: () => false,
-    loadCoreMemoryContext: async () => '# should not inject',
-    activeWorkflowContext: () => ({
-      summary: { id: 'solo', name: 'Solo', description: 'Lead works alone.', source: 'built-in', delegatesAgents: false },
-      context: '# Active Workflow: Solo — Lead works alone.',
-    }),
-    invalidatePreSessionToolSurface: () => {},
-  });
-  const bp1BeforeRefresh = session.messages[0];
-  const bp3BeforeRefresh = session.messages[2];
-  const result = await refreshEmptySessionToolPolicy();
-  assert.equal(result.appliedToCurrentSession, true);
-  assert.equal(session.workflow.delegatesAgents, false);
-  assert.deepEqual(session.tools.map((tool) => tool.name), ['read']);
-  const bp1 = session.messages[0].content;
-  assert.equal(bp1.includes('`web_search`'), false);
-  assert.equal(bp1.includes('`memory`'), false);
-  assert.notEqual(session.messages[0], bp1BeforeRefresh);
-  assert.notEqual(session.messages[2], bp3BeforeRefresh);
-  assert.match(session.messages[2].content, /# Active Workflow: Solo/);
-  assert.equal(session.messages[2].content.includes('# Core Memory'), false);
-});
-
-test('refresh leaves a conversation session frozen', async () => {
-  const session = {
-    id: 'sess_live',
-    messages: [{ role: 'user', content: 'hello' }, { role: 'assistant', content: 'hi' }],
-    tools: [{ name: 'agent' }, { name: 'web_search' }],
-    workflow: { id: 'default', delegatesAgents: true },
-  };
-  const { refreshEmptySessionToolPolicy } = createToolPolicyRefresh({
-    getSession: () => session,
-    getRoute: () => ({ provider: 'grok-oauth' }),
-    getMode: () => 'full',
-    getConfig: () => ({}),
-    getDataDir: () => '',
-    modelStandaloneTools: () => [{ name: 'read' }],
-    featureDisallowedTools: () => ['web_search'],
-    memoryToolsEnabled: () => false,
-    loadCoreMemoryContext: async () => '',
-    activeWorkflowContext: () => ({
-      summary: { id: 'solo', delegatesAgents: false },
-      context: '# Active Workflow: Solo',
-    }),
-    invalidatePreSessionToolSurface: () => {},
-  });
-  const result = await refreshEmptySessionToolPolicy();
-  assert.equal(result.appliedToCurrentSession, false);
-  assert.deepEqual(session.tools.map((tool) => tool.name), ['agent', 'web_search']);
-});

package/src/standalone/agent-tool/helpers.test.mjs

@@ -1,62 +0,0 @@
-import assert from 'node:assert/strict';
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import test from 'node:test';
-
-import { resolvePrompt, rowMatchesContext, sessionMatchesContext } from './helpers.mjs';
-
-test('parallel same-name agent prompts and files keep their own payloads', async () => {
-  const cwd = await mkdtemp(join(tmpdir(), 'mixdog-agent-prompts-'));
-  try {
-    await Promise.all([
-      writeFile(join(cwd, 'first.md'), 'first file payload'),
-      writeFile(join(cwd, 'second.md'), 'second file payload'),
-    ]);
-    const calls = [
-      { agent: 'reviewer', tag: 'first', prompt: 'first string prompt' },
-      { agent: 'reviewer', tag: 'second', file: 'second.md' },
-      { agent: 'reviewer', tag: 'third', file: 'first.md' },
-      { agent: 'reviewer', tag: 'fourth', message: 'fourth string prompt' },
-    ];
-    assert.deepEqual(await Promise.all(calls.map((args) => resolvePrompt(args, cwd))), [
-      'first string prompt',
-      'second file payload',
-      'first file payload',
-      'fourth string prompt',
-    ]);
-  } finally {
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test('same-tag reuse preserves string messages and rejects object coercion', async () => {
-  const first = { type: 'spawn', tag: 'legacy-session', prompt: 'initial brief' };
-  const reuse = { type: 'spawn', tag: 'legacy-session', message: 'follow-up brief' };
-  assert.equal(await resolvePrompt(first), 'initial brief');
-  assert.equal(await resolvePrompt(reuse), 'follow-up brief');
-  await assert.rejects(resolvePrompt({ prompt: { text: 'not a string' } }), {
-    name: 'TypeError',
-    message: 'agent: prompt/message must be a string',
-  });
-  await assert.rejects(resolvePrompt({ message: ['not', 'a', 'string'] }), {
-    name: 'TypeError',
-    message: 'agent: prompt/message must be a string',
-  });
-});
-
-test('agent scope is strictly session-owned when the context carries a session id', () => {
-  const context = { callerSessionId: 'sess_owner', clientHostPid: 100 };
-  // Owner match wins; a pid match alone must NOT leak a sibling session's agent.
-  assert.equal(rowMatchesContext({ ownerSessionId: 'sess_owner', clientHostPid: 100 }, context), true);
-  assert.equal(rowMatchesContext({ ownerSessionId: 'sess_other', clientHostPid: 100 }, context), false);
-  assert.equal(rowMatchesContext({ ownerSessionId: null, clientHostPid: 100 }, context), false);
-  assert.equal(sessionMatchesContext({ ownerSessionId: 'sess_owner', clientHostPid: 100 }, context), true);
-  assert.equal(sessionMatchesContext({ ownerSessionId: 'sess_other', clientHostPid: 100 }, context), false);
-  assert.equal(sessionMatchesContext({ parentSessionId: 'sess_owner', clientHostPid: 200 }, context), true);
-  // Without a caller session id, pid scoping is unchanged.
-  assert.equal(rowMatchesContext({ ownerSessionId: 'sess_other', clientHostPid: 100 }, { clientHostPid: 100 }), true);
-  assert.equal(rowMatchesContext({ clientHostPid: 200 }, { clientHostPid: 100 }), false);
-  // Unscoped context (scope:'all') sees everything.
-  assert.equal(rowMatchesContext({ ownerSessionId: 'sess_other' }, {}), true);
-});

package/src/standalone/agent-tool/notify.test.mjs

@@ -1,37 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-
-import { createNotify } from './notify.mjs';
-
-test('Subagent tool completion stays in the worker session', () => {
-  const queued = [];
-  const ownerDeliveries = [];
-  const { workerNotifyFn } = createNotify({
-    enqueuePendingMessage(sessionId, message) {
-      queued.push({ sessionId, message });
-      return 1;
-    },
-  }, {
-    notifySessionCompletion(sessionId, text, meta) {
-      ownerDeliveries.push({ sessionId, text, meta });
-      return true;
-    },
-  });
-
-  const delivered = workerNotifyFn('sess_worker', {
-    callerSessionId: 'sess_lead',
-  })(
-    'Async shell task job_test (completed, exit 0) finished.\n\nresult',
-    {
-      type: 'shell_task_result',
-      execution_surface: 'shell',
-      execution_id: 'job_test',
-      status: 'completed',
-    },
-  );
-
-  assert.equal(delivered, true);
-  assert.equal(ownerDeliveries.length, 0);
-  assert.equal(queued.length, 1);
-  assert.equal(queued[0].sessionId, 'sess_worker');
-});

package/src/standalone/agent-tool/spawn-flow.test.mjs

@@ -1,63 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-
-import { cleanupBackgroundTasks } from '../../runtime/shared/background-tasks.mjs';
-import { createSpawnFlow } from './spawn-flow.mjs';
-
-test('agent job lifecycle publishes status immediately and after terminal settlement', async () => {
-  let publications = 0;
-  const flow = createSpawnFlow({
-    mgr: { closeSession() {} },
-    notifyStatusChange: () => { publications += 1; },
-  });
-
-  const job = flow.startJob(
-    'spawn',
-    { tag: 'status-test' },
-    async () => ({ content: 'done' }),
-    { callerSessionId: 'lead-test', clientHostPid: process.pid },
-  );
-
-  assert.equal(job.status, 'running');
-  assert.equal(publications, 1);
-  await job.promise;
-  await new Promise((resolve) => setImmediate(resolve));
-  assert.equal(job.status, 'completed');
-  assert.ok(publications >= 2);
-  cleanupBackgroundTasks({ surface: 'agent', force: true });
-});
-
-test('agent job completion uses immutable caller owner and never invokes stale notify context', async () => {
-  const deliveries = [];
-  let staleCalls = 0;
-  const flow = createSpawnFlow({
-    mgr: { closeSession() {} },
-    notifySessionCompletion(sessionId, text, meta) {
-      deliveries.push({ sessionId, text, meta });
-      return true;
-    },
-  });
-
-  const job = flow.startJob(
-    'spawn',
-    { tag: 'owner-test' },
-    async () => ({ content: 'owner handoff' }),
-    {
-      callerSessionId: 'lead-owner',
-      routingSessionId: 'wrong-lead',
-      clientHostPid: process.pid,
-      notifyFn() {
-        staleCalls += 1;
-        return true;
-      },
-    },
-  );
-
-  await job.promise;
-  assert.equal(staleCalls, 0);
-  assert.ok(deliveries.length >= 1);
-  assert.ok(deliveries.every((entry) => entry.sessionId === 'lead-owner'));
-  assert.ok(deliveries.every((entry) => entry.meta.caller_session_id === 'lead-owner'));
-  assert.match(deliveries.at(-1).text, /owner handoff/);
-  cleanupBackgroundTasks({ surface: 'agent', force: true });
-});