@xingular/harness 1.3.1-unstable.0 → 1.3.1-unstable.2

package/dist/sdk/sessions/sessions.js

@@ -18,15 +18,17 @@ import { FIRST_PARTY_PLUGINS, firstPartyExtensions } from "../plugins/firstParty
 import { imagePruning } from "../world/images.js";
 import { materialise } from "../variant/materialise.js";
 import { ASK_USER } from "../tools/askUser.js";
+import { defaultSkillPaths } from "../tools/defaultSkills.js";
 import { TODO_WRITE } from "../tools/todo.js";
 import { CHECKPOINT_WRITE, checkpointOf } from "../tools/checkpoint.js";
-import { SESSION_NAME, sessionNameTool } from "../tools/sessionName.js";
+import { SESSION_NAME, deriveSessionName, sessionNameTool } from "../tools/sessionName.js";
 import { DEFAULT_TOOL_NAMES } from "../tools/definitions.js";
 import { GET_CAPABILITIES, getCapabilitiesTool } from "../tools/getCapabilities.js";
 import { isActiveStatus } from "./contracts.js";
 import { SPAWN_SUBAGENT, WAIT_SUBAGENTS, subagentDepth, subagentHistory, subagentNesting } from "./subagents.js";
 import { selectHistory } from "./history.js";
 import { runLineageJoin } from "./lineageJoin.js";
+import { latestSessionName } from "./sessionState.js";
 import { compactionCheckpoint, COMPACTION_CHECKPOINT_EXTENSION } from "./compactionCheckpoint.js";
 import { createSliceState, parseWorkSlice, sliceOf, workSliceGuard, WorkSliceError, WORK_SLICE_EXTENSION } from "./workSlice.js";
 import { piSessionFactory, runTurn, summarize } from "./runner.js";
@@ -468,6 +470,28 @@ export class Sessions {
             updateRun(root, runId, (record) => Object.assign(record, { status: 'failed', endedAt: now(), terminalReason: message }));
             log(`session ${runId} did not start: ${message}`, code);
         };
+        // Plugins are resolved once per run: for the profiles the prompt lists, then for what Pi loads.
+        const { plugins } = this.options;
+        let pluginLoading = null;
+        const loadPlugins = plugins
+            ? () => (pluginLoading ??= plugins.loading({ cwd: input.cwd, agentDir: context.configDir, install: true, caller: { agentId: caller.agentId ?? null, projectId: caller.projectId ?? null }, contributions: capabilities.contributions }))
+            : null;
+        // A person's main session sees its current name and whether this run's todo is empty. A
+        // command, child, side question or unattended run has no such state to show.
+        const stateEligible = !input.command
+            && !input.run.relation
+            && (input.depth ?? 0) === 0
+            && !input.automatic
+            && (input.run.trigger == null || input.run.trigger === 'user');
+        const existingName = stateEligible ? latestSessionName(historyFile) : null;
+        const sessionState = stateEligible
+            ? {
+                name: existingName,
+                todo: [],
+                ...(continuation?.todo.length ? { previousTodo: continuation.todo } : {}),
+                firstTurn: !historyFile
+            }
+            : undefined;
         let system;
         let update;
         try {
@@ -483,14 +507,17 @@ export class Sessions {
                 contributions: capabilities.contributions,
                 descriptors: BUILTIN_PLUGIN_REGISTRY.descriptors()
             } : undefined;
+            if (capabilities.tools.includes(SPAWN_SUBAGENT) && loadPlugins && !input.automatic)
+                input.packageProfiles = (await loadPlugins()).profilePaths;
             const profiles = capabilities.tools.includes(SPAWN_SUBAGENT)
-                ? profileSection(root, input.cwd, variant?.dir ?? null, input.plan === true, researchContext)
+                ? profileSection(root, input.cwd, variant?.dir ?? null, input.plan === true, researchContext, input.packageProfiles ?? [])
                 : null;
             if (profiles && variant)
                 variant = { ...variant, sections: variant.sections.filter((section) => section.id !== profiles.id) };
             const own = [plan, resumed, profiles].filter((section) => section !== null);
             const effectiveLaunch = {
                 ...launch,
+                ...(sessionState ? { sessionState } : {}),
                 sections: own.length ? [...(launch.sections ?? []).filter((section) => !own.some((entry) => entry.id === section.id)), ...own] : launch.sections,
                 tools: capabilities.tools,
                 connectionTools: (launch.connectionTools ?? []).filter((name) => capabilities.tools.includes(name)),
@@ -516,7 +543,6 @@ export class Sessions {
         // What every session has, after the tools the caller switched on and in a fixed order.
         const allow = capabilities.tools;
         const session = { run, caller, allow, depth, cwd: input.cwd, capabilities };
-        const { plugins } = this.options;
         let pi;
         const naming = sessionNameTool(() => {
             const current = pi;
@@ -598,7 +624,7 @@ export class Sessions {
                 preamble: input.preamble ?? null,
                 automatic: input.automatic,
                 account: context,
-                resources: { ids: [], skillPaths: variant?.skillPaths ?? [], promptPaths: [] },
+                resources: { ids: [], skillPaths: [...(variant?.skillPaths ?? []), ...defaultSkillPaths(variant?.dir)], promptPaths: [] },
                 variantExtensions: variant?.extensionPaths ?? [],
                 inline: [
                     ...firstPartyFor(root, capabilities.contributions),
@@ -608,7 +634,7 @@ export class Sessions {
                     { name: COMPACTION_CHECKPOINT_EXTENSION, factory: compactionCheckpoint({ initialTodo: continuation?.todo, planInstructions: checkpointPlanInstructions }) },
                     ...(sliceEnabled ? [{ name: WORK_SLICE_EXTENSION, factory: workSliceGuard({ policy: slicePolicy, state: sliceState, checkpointAvailable }) }] : [])
                 ],
-                ...(plugins ? { plugins: { loading: () => plugins.loading({ cwd: input.cwd, agentDir: context.configDir, install: true, caller: { agentId: caller.agentId ?? null, projectId: caller.projectId ?? null }, contributions: capabilities.contributions }), loaded: (extensions) => plugins.loaded(extensions) } } : {}),
+                ...(plugins && loadPlugins ? { plugins: { loading: loadPlugins, loaded: (extensions) => plugins.loaded(extensions) } } : {}),
                 system,
                 ...(sliceEnabled ? { slice: { state: sliceState, maxToolCalls: slicePolicy.maxToolCalls } } : {}),
                 // A command sends no request of its own, so the context update waits for the next turn.
@@ -635,6 +661,20 @@ export class Sessions {
                 run.finish('failed', { code: 'native_resume_unavailable', message: 'The saved conversation could not be restored.' });
                 throw new HarnessError('native_resume_unavailable', 'The saved conversation could not be restored.');
             }
+            // The fallback is a name, not a task step: a refused or failed name never fails the run.
+            if (stateEligible && input.autoName !== false && !existingName && !pi.sessionName
+                && pi.setSessionName && capabilities.tools.includes(SESSION_NAME)) {
+                const name = deriveSessionName(input.text);
+                if (name) {
+                    try {
+                        if (await gate.check(SESSION_NAME, { name }) === null)
+                            pi.setSessionName(name);
+                    }
+                    catch {
+                        // Session naming is metadata; leave the session unnamed.
+                    }
+                }
+            }
             const opened = pi;
             const openedModel = pi.model?.id && pi.model.provider ? `${pi.model.provider}/${pi.model.id}` : null;
             updateRun(root, runId, (record) => {

package/dist/sdk/sessions/subagentService.js

@@ -122,7 +122,7 @@ export class Subagents {
         if (request.tools !== undefined && (!Array.isArray(request.tools) || request.tools.some(name => typeof name !== 'string'))) {
             return { refusal: 'The optional tools field must be an array of tool names. Omit it to inherit the selected profile’s safe research intersection.' };
         }
-        const profile = resolveProfile(this.env.root, parent.input.cwd, request.agent.trim(), parent.input.variant && 'dir' in parent.input.variant ? parent.input.variant.dir : null);
+        const profile = resolveProfile(this.env.root, parent.input.cwd, request.agent.trim(), parent.input.variant && 'dir' in parent.input.variant ? parent.input.variant.dir : null, parent.input.packageProfiles);
         if (!profile)
             return { refusal: `There is no agent profile named ${request.agent.trim()}.` };
         const eligibility = planResearchEligibility(profile, {
@@ -169,7 +169,7 @@ export class Subagents {
             if (request.agent !== undefined) {
                 if (typeof request.agent !== 'string' || !request.agent.trim())
                     throw invalid('agent must be the name of an agent profile.');
-                profile = resolveProfile(this.env.root, input.cwd, request.agent.trim(), input.variant && 'dir' in input.variant ? input.variant.dir : null);
+                profile = resolveProfile(this.env.root, input.cwd, request.agent.trim(), input.variant && 'dir' in input.variant ? input.variant.dir : null, input.packageProfiles);
                 if (!profile)
                     throw invalid(`There is no agent profile named ${request.agent.trim()}.`);
             }
@@ -306,7 +306,7 @@ export class Subagents {
             throw invalid(`Subagent ${latest.id} needs capabilities you do not have in this run: ${missing.join(', ')}. Start a new subagent instead.`);
         let profile = null;
         if (latest.profile)
-            profile = resolveProfile(root, input.cwd, latest.profile, input.variant && 'dir' in input.variant ? input.variant.dir : null);
+            profile = resolveProfile(root, input.cwd, latest.profile, input.variant && 'dir' in input.variant ? input.variant.dir : null, input.packageProfiles);
         if (input.plan) {
             // A plan run continues only a research child whose pinned tools still qualify.
             const check = latest.profile ? this.planSpawnCheck(request.parentRunId, { agent: latest.profile }) : { refusal: 'Plan mode can continue only a stopped research subagent that has a named profile.' };

package/dist/sdk/terminal/opentui/theme.d.ts

@@ -17,6 +17,8 @@ export interface OpenTuiTheme {
     questionActionText: string;
     primary: string;
     accent: string;
+    /** A link under the pointer, one step brighter than the link itself. */
+    linkHover: string;
     success: string;
     warning: string;
     error: string;

package/dist/sdk/terminal/opentui/theme.js

@@ -17,6 +17,7 @@ export const opentuiTheme = {
     questionActionText: '#f7fff8',
     primary: '#fab283',
     accent: '#8ab4f8',
+    linkHover: '#c9ddff',
     success: '#a6da95',
     warning: '#eed49f',
     error: '#ed8796',

package/dist/sdk/terminal/piExtension.js

@@ -9,14 +9,15 @@ import { controlCall } from "./control.js";
 import { SPAWN_SUBAGENT, SUBAGENT_OWNER, SUBAGENT_RECEIPT, SUBAGENT_RESULTS, subagentHistory } from "../sessions/subagents.js";
 import { PLAN_RESEARCH_TOOLS } from "../agents/planResearch.js";
 import { askUserTool } from "../tools/askUser.js";
-import { todoTool } from "../tools/todo.js";
+import { TODO_WRITE, todoTool } from "../tools/todo.js";
 import { CHECKPOINT_WRITE, checkpointTool } from "../tools/checkpoint.js";
 import { createSliceState, parseWorkSlice, workSliceGuard } from "../sessions/workSlice.js";
 import { DEFAULT_COMMAND_TIMEOUT_SECONDS, withCommandBudget } from "../core/commandBudget.js";
-import { sessionNameTool } from "../tools/sessionName.js";
+import { SESSION_NAME, deriveSessionName, sessionNameTool } from "../tools/sessionName.js";
 import { CAPABILITY_DISCOVERY, describeCapabilities } from "../tools/getCapabilities.js";
 import { PLAN_INSTRUCTIONS, planRefusal } from "../sessions/planMode.js";
 import { compactionCheckpoint } from "../sessions/compactionCheckpoint.js";
+import { sessionStateText } from "../prompt/compile.js";
 import { pruneToolImages } from "../world/images.js";
 import { parseInitialBashCommand } from "../sessions/initialBash.js";
 import { inspectWorkspaceWrite } from "../sessions/workspaceBoundary.js";
@@ -61,6 +62,10 @@ export default async function (pi, planRun, getSession) {
     const fileTools = new Map();
     const writeAuthorizations = new Map();
     let workspaceRoot = null;
+    let sessionState = null;
+    let stateDelivered = false;
+    let autoNameTried = false;
+    let lastTodo = [];
     // The harness's own tools for this session (connected apps and what the application offers).
     let stage = 'Tool discovery';
     try {
@@ -139,6 +144,21 @@ export default async function (pi, planRun, getSession) {
     pi.registerTool(createWorkspaceShellTool({ createBashTool, createPowerShellTool }, process.cwd(), workspaceBash));
     pi.registerTool(withWorkspaceWriteAuthorization(createWriteTool(process.cwd(), { operations: workspaceWriteOperations }), writeAuthorizations));
     pi.registerTool(withWorkspaceWriteAuthorization(createEditTool(process.cwd(), { operations: workspaceEditOperations }), writeAuthorizations));
+    // The current name and this run's todo ride with each request; they never change the stable prefix.
+    pi.on('context', (event) => {
+        if (!sessionState || stateDelivered)
+            return;
+        stateDelivered = true;
+        return {
+            messages: [...event.messages, {
+                    role: 'custom',
+                    customType: 'xingular-session-state',
+                    content: sessionState,
+                    display: false,
+                    timestamp: Date.now()
+                }]
+        };
+    });
     compactionCheckpoint({ planInstructions: () => planRun?.active ? PLAN_INSTRUCTIONS : null })(pi);
     // A terminal reply is bounded like any other (PROP-0041): a checkpoint at the boundary, then the
     // person decides whether to continue.
@@ -154,6 +174,10 @@ export default async function (pi, planRun, getSession) {
     });
     pi.on('session_start', async (_event, ctx) => {
         context = ctx;
+        sessionState = null;
+        stateDelivered = false;
+        autoNameTried = false;
+        lastTodo = [];
         if (timer)
             clearInterval(timer);
         // The branch's parent runs let the controller show the latest one's rows again on reopen.
@@ -274,6 +298,44 @@ export default async function (pi, planRun, getSession) {
         if (notice)
             return { message: { customType: SUBAGENT_RESULTS, content: notice.text, display: false, details: { [SUBAGENT_RECEIPT]: notice.receipt } } };
     });
+    // A new user turn starts with an empty todo. The previous list is context, not this run's list.
+    // A substantive first turn also gets a provisional name when the terminal policy allows it.
+    pi.on('before_agent_start', async (event, ctx) => {
+        if (event.messageType !== 'user')
+            return;
+        const branch = ctx.sessionManager.getBranch?.() ?? [];
+        const hasUser = branch.some((entry) => entry.type === 'message' && entry.message?.role === 'user');
+        let name = typeof pi.getSessionName === 'function' ? pi.getSessionName() ?? null : null;
+        if (!name && !autoNameTried && pi.setSessionName) {
+            const candidate = deriveSessionName(event.prompt);
+            if (candidate) {
+                autoNameTried = true;
+                try {
+                    const policy = await controlCall('terminal.policy', { tool: SESSION_NAME, args: { name: candidate } });
+                    if (policy.allowed && !policy.requiresApproval) {
+                        pi.setSessionName(candidate);
+                        name = candidate;
+                    }
+                }
+                catch {
+                    // Session naming is metadata; a refused or failed name never fails the turn.
+                }
+            }
+        }
+        const state = {
+            name,
+            todo: [],
+            ...(lastTodo.length ? { previousTodo: lastTodo } : {}),
+            firstTurn: !hasUser
+        };
+        lastTodo = [];
+        const active = typeof pi.getActiveTools === 'function' ? pi.getActiveTools() : null;
+        sessionState = sessionStateText(state, {
+            name: active ? active.includes(SESSION_NAME) : true,
+            todo: active ? active.includes(TODO_WRITE) : true
+        });
+        stateDelivered = false;
+    });
     const deliverChildren = async (event, ctx, settle) => {
         if (!nativeSubagents || (settle && event.outcome !== 'completed') || ctx.signal?.aborted)
             return;
@@ -435,6 +497,10 @@ export default async function (pi, planRun, getSession) {
             clearInterval(timer);
         timer = null;
         context = null;
+        sessionState = null;
+        stateDelivered = false;
+        autoNameTried = false;
+        lastTodo = [];
         // This clears the controller's readiness while the next native session binds. The
         // process-level control claim survives replacement; only the session poller stops.
         await terminalCall('shutdown').catch(() => { });
@@ -461,6 +527,9 @@ export default async function (pi, planRun, getSession) {
             recorded = Promise.resolve();
             const result = await todo.execute(input);
             await recorded;
+            const items = input.items;
+            if (Array.isArray(items))
+                lastTodo = items;
             return { content: [{ type: 'text', text: typeof result === 'string' ? result : result.text }], details: undefined };
         }
     });

package/dist/sdk/terminal/terminals.d.ts

@@ -11,6 +11,7 @@ import type { CallerContext } from "../core/caller.js";
 import { type VariantChoice } from "../variant/materialise.js";
 import type { VariantTrust } from "../variant/trust.js";
 import type { AttachParams, PluginScope } from "../plugins/api.js";
+import type { Proposal } from "../plugins/proposals.js";
 import type { Plugins } from "../plugins/plugins.js";
 import type { Plugin } from "../plugins/types.js";
 import type { Hub } from "../hub/hub.js";
@@ -131,6 +132,12 @@ export interface PluginControl {
     remove?(params: PluginScope & {
         pluginId: string;
     }): Promise<Plugin[]>;
+    proposals?: {
+        list(): Proposal[] | Promise<Proposal[]>;
+        preview(id: string): Proposal | Promise<Proposal>;
+        accept(id: string, hash: string): Proposal | Promise<Proposal>;
+        reject(id: string, hash: string): Proposal | Promise<Proposal>;
+    };
 }
 export declare class Terminals {
     private readonly options;
@@ -138,6 +145,8 @@ export declare class Terminals {
     private readonly diagnosticOwners;
     /** The variant each live session runs, for loading its skills. */
     private readonly variantDirs;
+    /** The subagent profile files each live session's packages bring, chosen when it started. */
+    private readonly packageProfiles;
     /** The world tools each session was given, so a call can only reach one of them. */
     private readonly worldNames;
     private readonly worldReadOnly;

package/dist/sdk/terminal/terminals.js

@@ -17,6 +17,7 @@ import { formatBashCommandForApproval } from "../core/workspaceBashTool.js";
 import { resolveWorkspaceRoot } from "../core/workspace.js";
 import { prependSearchPath, searchPath } from "../core/path.js";
 import { dispatch } from "../tools/dispatch.js";
+import { defaultSkillPaths } from "../tools/defaultSkills.js";
 import { materialise } from "../variant/materialise.js";
 import * as componentLibrary from "../variant/components.js";
 import * as variantStore from "../variant/store.js";
@@ -50,7 +51,7 @@ function resourceIdentity(loading) {
         return 'null';
     return JSON.stringify({
         extensions: loading.extensionPaths, builtins: loading.builtins, skills: loading.skillPaths,
-        prompts: loading.promptPaths, themes: loading.themePaths, detached: loading.detached,
+        prompts: loading.promptPaths, themes: loading.themePaths, profiles: loading.profilePaths, detached: loading.detached,
         project: loading.projectCode, packages: loading.packageCode
     });
 }
@@ -72,6 +73,8 @@ export class Terminals {
     diagnosticOwners = new Map();
     /** The variant each live session runs, for loading its skills. */
     variantDirs = new Map();
+    /** The subagent profile files each live session's packages bring, chosen when it started. */
+    packageProfiles = new Map();
     /** The world tools each session was given, so a call can only reach one of them. */
     worldNames = new Map();
     worldReadOnly = new Set();
@@ -358,6 +361,19 @@ export class Terminals {
             return params[name];
         };
         switch (call) {
+            case 'plugins.proposals.list':
+                if (!api.proposals)
+                    throw invalid('Proposal review is unavailable in this host.');
+                return api.proposals.list();
+            case 'plugins.proposals.preview':
+                if (!api.proposals)
+                    throw invalid('Proposal review is unavailable in this host.');
+                return api.proposals.preview(text('id'));
+            case 'plugins.proposals.accept':
+            case 'plugins.proposals.reject':
+                if (!api.proposals)
+                    throw invalid('Proposal review is unavailable in this host.');
+                return api.proposals[call === 'plugins.proposals.accept' ? 'accept' : 'reject'](text('id'), text('hash'));
             case 'plugins.attach':
             case 'plugins.detach':
                 return api.attach({ ...scope, id: text('id'), scope: params.everywhere === true || !projectId ? {} : { projectId } }, call === 'plugins.attach');
@@ -481,7 +497,7 @@ export class Terminals {
             return params.scope;
         };
         switch (call.slice('terminal.agents.'.length)) {
-            case 'list': return { ...listProfiles(root, cwd, this.variantDirs.get(live.input.sessionId) ?? null), dirs: profileDirs(root, cwd) };
+            case 'list': return { ...listProfiles(root, cwd, this.variantDirs.get(live.input.sessionId) ?? null, this.packageProfiles.get(live.input.sessionId)), dirs: profileDirs(root, cwd) };
             case 'create': return createProfile(root, cwd, { name: name(), scope: scope(), from: typeof params.from === 'string' && params.from ? params.from : null });
             case 'remove':
                 removeProfile(root, cwd, { name: name(), scope: scope() });
@@ -582,6 +598,9 @@ export class Terminals {
         if (call === 'terminal.usage.limits') {
             return params.refresh === true ? limits.refresh(live.account.id, { force: true }) : limits.read(live.account.id);
         }
+        if (call === 'terminal.usage.allLimits') {
+            return params.refresh === true ? limits.refresh() : limits.read();
+        }
         if (call === 'terminal.usage.headers') {
             if (typeof params.provider !== 'string' || !params.provider)
                 throw invalid('A provider is required.');
@@ -636,14 +655,14 @@ export class Terminals {
             case 'read': return pageNotes.read(root, id());
             case 'create': {
                 const note = pageNotes.create(root, { source: params.source, target: params.target, body: params.body, tags: params.tags });
-                return params.share === true ? pageNotes.share(root, note.id, { sessionId }) : note;
+                return params.share === true ? needNotes().share(note.id, undefined, sessionId) : note;
             }
             case 'update': return pageNotes.update(root, id(), version(), (params.patch ?? {}));
             case 'delete':
                 pageNotes.remove(root, id(), version());
                 return {};
             // A terminal shares with, and withdraws from, its own session only.
-            case 'share': return pageNotes.share(root, id(), { sessionId });
+            case 'share': return needNotes().share(id(), undefined, sessionId);
             case 'unshare': return pageNotes.unshare(root, id(), { sessionId });
             case 'open': return needCapture().open(sessionId, typeof params.url === 'string' && params.url ? params.url : null);
             case 'identity': return needCapture().identity(sessionId);
@@ -662,7 +681,7 @@ export class Terminals {
                 const note = pageNotes.read(root, id());
                 return needCapture().reveal(sessionId, note.source.url, note.target);
             }
-            // ---- The inspector and the queue (PROP-0018); a terminal queues and sends to its own session.
+            // ---- The inspector and sending (PROP-0018, PROP-0042); a terminal shares with and sends to its own session.
             case 'target': return { ...needCapture().describe(sessionId), windows: await needCapture().windows(sessionId).catch(() => []) };
             case 'attach': {
                 const kind = params.kind;
@@ -684,10 +703,18 @@ export class Terminals {
                 await needCapture().stopInspect(sessionId);
                 return {};
             case 'next': return inspectStep(needCapture(), needNotes(), sessionId, sessionId, 'terminal');
-            case 'queue': return needNotes().queue(id(), version(), sessionId);
-            case 'dequeue': return needNotes().dequeue(id(), version());
             case 'confirm': return needNotes().confirm(id(), version());
-            case 'send': return needNotes().send(sessionId, { ids: Array.isArray(params.ids) ? params.ids.filter((entry) => typeof entry === 'string') : null });
+            case 'confirmAll': return { notes: needNotes().confirmAll(sessionId) };
+            case 'clear': return { notes: needNotes().clear(sessionId) };
+            case 'send': return needNotes().send(sessionId, {
+                ids: Array.isArray(params.ids) ? params.ids.filter((entry) => typeof entry === 'string') : null,
+                prompt: typeof params.prompt === 'string' ? params.prompt : null
+            });
+            case 'discover': return { apps: await needCapture().discover() };
+            case 'launch':
+                if (typeof params.path !== 'string' || !params.path.trim())
+                    throw invalid('Give the path of the app to start.');
+                return needCapture().launchApp(sessionId, params.path, Array.isArray(params.args) ? params.args.filter((entry) => typeof entry === 'string') : []);
             default:
                 throw new HarnessError('unknown_method', `Unknown call ${call}.`);
         }
@@ -886,11 +913,12 @@ export class Terminals {
         }
         if (call === 'terminal.subagents.tools') {
             const variantDir = this.variantDirs.get(live.input.sessionId) ?? null;
+            const packaged = this.packageProfiles.get(live.input.sessionId) ?? [];
             return {
                 tools: subagentTools(service, '').map(tool => ({ name: tool.name, label: tool.label, description: tool.description, parameters: tool.parameters(Type) })),
                 profiles: {
-                    normal: profileSection(this.options.env.root, live.input.cwd, variantDir).body,
-                    plan: profileSection(this.options.env.root, live.input.cwd, variantDir, true).body
+                    normal: profileSection(this.options.env.root, live.input.cwd, variantDir, false, undefined, packaged).body,
+                    plan: profileSection(this.options.env.root, live.input.cwd, variantDir, true, undefined, packaged).body
                 }
             };
         }
@@ -912,13 +940,14 @@ export class Terminals {
             const caller = { ...live.caller, runId: run.runId };
             const capabilities = this.options.resolveCapabilities ? await this.options.resolveCapabilities(caller, tools, live.input.cwd) : { version: 1, tools, connectors: [], contributions: [] };
             const variantDir = this.variantDirs.get(live.input.sessionId) ?? null;
+            const packaged = this.packageProfiles.get(live.input.sessionId) ?? [];
             const subagentProfiles = {
-                normal: profileSection(this.options.env.root, live.input.cwd, variantDir).body,
+                normal: profileSection(this.options.env.root, live.input.cwd, variantDir, false, undefined, packaged).body,
                 plan: profileSection(this.options.env.root, live.input.cwd, variantDir, true, {
                     frozenTools: capabilities.tools,
                     contributions: capabilities.contributions,
                     descriptors: HARNESS_PLUGINS
-                }).body
+                }, packaged).body
             };
             freezeRun(this.options.env.root, run.runId, caller, capabilities);
             if (!service || live.input.subagents === null)
@@ -932,6 +961,7 @@ export class Terminals {
                 connections: live.input.connections === false ? false : { readOnly }, subagents: live.input.subagents,
                 plan: params.plan === true,
                 variant: live.variant ? { dir: live.variant.dir, scope: live.variant.scope } : null,
+                packageProfiles: packaged,
                 capabilities
             }, live.account.id, capabilities);
             const history = params.history ?? { owners: [], receipts: [] };
@@ -1097,11 +1127,12 @@ export class Terminals {
                 plugins: () => this.options.pluginControl?.list({ cwd: input.cwd, accountId: preparedAccount.id, projectId: input.projectId ?? null }) ?? Promise.resolve([]) });
             if (variant)
                 this.variantDirs.set(sessionId, variant.dir);
+            this.packageProfiles.set(sessionId, loading?.profilePaths ?? []);
             const worldTools = await this.worldToolNames(input, preparedAccount);
             const ownTools = await this.ownToolNames(input, preparedAccount);
             const launchTools = [...new Set([...(input.launch?.tools ?? []), TODO_WRITE, SESSION_NAME, ...ownTools, ...(broker ? apps.toolNames : []), ...worldTools])];
             // The profiles replace the variant's own subagent list, which they include.
-            const profiles = this.options.subagents && input.subagents !== null ? profileSection(root, input.cwd, variant?.dir ?? null) : null;
+            const profiles = this.options.subagents && input.subagents !== null ? profileSection(root, input.cwd, variant?.dir ?? null, false, undefined, loading?.profilePaths ?? []) : null;
             const launchSections = profiles ? [...(input.launch?.sections ?? []).filter((section) => section.id !== profiles.id), profiles] : input.launch?.sections;
             // A terminal is a person's own session: the same standard sections a host's session has.
             const standard = input.launch?.standard === null ? null : input.launch?.standard ?? { cwd: input.cwd };
@@ -1280,7 +1311,7 @@ export class Terminals {
                 // The pi command's own extensions are not loaded: a host's session cannot have them (PROP-0039).
                 for (const path of [...(loading?.extensionPaths ?? []), ...(variant?.extensionPaths ?? [])])
                     args.push('--extension', path);
-                for (const path of [...(variant?.skillPaths ?? []), ...(loading?.skillPaths ?? [])])
+                for (const path of [...(variant?.skillPaths ?? []), ...defaultSkillPaths(variant?.dir), ...(loading?.skillPaths ?? [])])
                     args.push('--skill', path);
                 for (const path of loading?.promptPaths ?? [])
                     args.push('--prompt-template', path);
@@ -1311,6 +1342,7 @@ export class Terminals {
                 this.socket.revoke(token);
             this.sessions.delete(sessionId);
             this.variantDirs.delete(sessionId);
+            this.packageProfiles.delete(sessionId);
             this.worldNames.delete(sessionId);
             if (this.worktreeLeases.get(sessionId) === acquiredWorktreeId)
                 this.worktreeLeases.delete(sessionId);

package/dist/sdk/terminal/tui/annotateCommand.d.ts

@@ -1,3 +1,7 @@
 import type { AnnotateStart } from "./pages/annotatePage.js";
-/** `/annotate:annotate` accepts a page address, DevTools target, or page-bridge target. */
+/** A typed page address: a bare host gets https, localhost gets http. */
+export declare function normalizeAddress(text: string): string;
+/** A typed DevTools port or loopback address. */
+export declare function normalizeDevTools(text: string): string;
+/** `/annotate:` accepts a page address, an app's DevTools port, or the page bridge. */
 export declare function parseAnnotate(argument: string): AnnotateStart | string;

package/dist/sdk/terminal/tui/annotateCommand.js

@@ -1,4 +1,20 @@
-/** `/annotate:annotate` accepts a page address, DevTools target, or page-bridge target. */
+/** A typed page address: a bare host gets https, localhost gets http. */
+export function normalizeAddress(text) {
+    const word = text.trim();
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(word))
+        return word;
+    return /^(localhost|127\.0\.0\.1)(:\d+)?(\/|$)/.test(word) ? `http://${word}` : `https://${word}`;
+}
+/** A typed DevTools port or loopback address. */
+export function normalizeDevTools(text) {
+    const word = text.trim();
+    if (/^\d+$/.test(word))
+        return `http://127.0.0.1:${word}`;
+    if (/^(localhost|127\.0\.0\.1|\[::1\]):\d+$/.test(word))
+        return `http://${word}`;
+    return word;
+}
+/** `/annotate:` accepts a page address, an app's DevTools port, or the page bridge. */
 export function parseAnnotate(argument) {
     const words = argument.trim().split(/\s+/).filter(Boolean);
     if (!words.length)
@@ -6,17 +22,15 @@ export function parseAnnotate(argument) {
     if (words[0] === '--app') {
         const endpoint = words[1];
         if (!endpoint)
-            return 'Give the app\'s DevTools address: /annotate:annotate --app http://127.0.0.1:9229';
-        const address = /^\d+$/.test(endpoint) ? `http://127.0.0.1:${endpoint}` : endpoint;
+            return { kind: 'apps' };
         const name = words.slice(2).join(' ');
-        return { kind: 'cdp', endpoint: address, ...(name ? { name } : {}) };
+        return { kind: 'cdp', endpoint: normalizeDevTools(endpoint), ...(name ? { name } : {}) };
     }
     if (words[0] === '--bridge') {
         const name = words.slice(1).join(' ');
         return { kind: 'bridge', ...(name ? { name } : {}) };
     }
     if (words.length > 1 || words[0].startsWith('--'))
-        return 'Use /annotate:annotate [url], /annotate:annotate --app <DevTools address>, or /annotate:annotate --bridge.';
-    const url = /^[a-z][a-z0-9+.-]*:\/\//i.test(words[0]) ? words[0] : /^(localhost|127\.0\.0\.1)(:\d+)?(\/|$)/.test(words[0]) ? `http://${words[0]}` : `https://${words[0]}`;
-    return { kind: 'web', url };
+        return 'Use /annotate: [url], /annotate: --app [port], or /annotate: --bridge.';
+    return { kind: 'web', url: normalizeAddress(words[0]) };
 }

package/dist/sdk/terminal/tui/annotateSend.d.ts

@@ -0,0 +1,30 @@
+import type { MenuCall } from "../pluginMenu.js";
+import type { Note } from "../../annotations/store.js";
+type SendResult = {
+    state: 'sent';
+    ids: string[];
+} | {
+    state: 'busy';
+    ids: string[];
+} | {
+    state: 'host';
+    ids: string[];
+} | {
+    state: 'empty';
+    ids: [];
+    unconfirmed?: number;
+};
+export interface AnnotateSendUi {
+    confirm(title: string, message: string): Promise<boolean>;
+}
+/** Unsent annotations of `sessionId`, oldest first. */
+export declare function unsent(notes: readonly Note[], sessionId: string | null): Note[];
+/**
+ * Sends every unsent annotation of this terminal's session, with `prompt` after them when given.
+ * Returns what to tell the person.
+ */
+export declare function sendUnsent(call: MenuCall, ui: AnnotateSendUi, options?: {
+    prompt?: string;
+}): Promise<string>;
+export declare function describeSend(result: SendResult, withPrompt?: boolean): string;
+export {};

package/dist/sdk/terminal/tui/annotateSend.js

@@ -0,0 +1,40 @@
+const count = (n) => `${n} annotation${n === 1 ? '' : 's'}`;
+/** Unsent annotations of `sessionId`, oldest first. */
+export function unsent(notes, sessionId) {
+    return notes
+        .filter((note) => note.status === 'open' && note.delivery?.state === 'pending' && note.delivery.sessionId === sessionId)
+        .sort((left, right) => left.delivery.queuedAt.localeCompare(right.delivery.queuedAt));
+}
+/**
+ * Sends every unsent annotation of this terminal's session, with `prompt` after them when given.
+ * Returns what to tell the person.
+ */
+export async function sendUnsent(call, ui, options = {}) {
+    const listed = await call('terminal.annotations.list');
+    const waiting = unsent(listed.notes, listed.sessionId);
+    if (!waiting.length) {
+        return options.prompt
+            ? 'No unsent annotations. Annotate something with /annotate: first, or send your request as a normal message.'
+            : 'Nothing to send. Annotate something first.';
+    }
+    const unconfirmed = waiting.filter((note) => note.delivery?.confirm);
+    if (unconfirmed.length) {
+        const yes = await ui.confirm(`Send ${count(waiting.length)} to the agent?`, `${count(unconfirmed.length)} came from the app's own page scripts, which could have written them. Check that the comments are yours.`);
+        if (!yes)
+            return 'Nothing was sent.';
+        await call('terminal.annotations.confirmAll');
+    }
+    const result = await call('terminal.annotations.send', options.prompt ? { prompt: options.prompt } : {});
+    return describeSend(result, !!options.prompt);
+}
+export function describeSend(result, withPrompt = false) {
+    if (result.state === 'sent')
+        return `Sent ${count(result.ids.length)} to the agent.`;
+    if (result.state === 'busy' && withPrompt)
+        return 'The agent is still working. Submit again when it finishes; your annotations stay unsent.';
+    if (result.state === 'busy')
+        return `The agent is working; ${count(result.ids.length)} go${result.ids.length === 1 ? 'es' : ''} out when it finishes.`;
+    if (result.state === 'host')
+        return `${count(result.ids.length)} handed to the app to send.`;
+    return result.unconfirmed ? `${count(result.unconfirmed)} still wait for your confirmation.` : 'Nothing to send.';
+}

package/dist/sdk/terminal/tui/commandPages.d.ts

@@ -7,7 +7,7 @@ export declare function createCommandPage(host: TerminalCommandHost, id: Command
     runId?: string;
     url?: string;
     annotate?: AnnotateStart;
-    usageTab?: 'analysis' | 'limit';
+    usageTab?: 'analysis' | 'limit' | 'accounts';
     usagePeriod?: 'today' | '7d' | '30d' | 'all';
     close?(): void;
 }): TerminalPage;