@xingular/harness 1.2.0 → 1.3.1-unstable.1

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

@@ -1,16 +1,25 @@
 import { BUILTIN_PLUGIN_REGISTRY } from "../../plugins/builtin.js";
 import { parseAnnotate } from "./annotateCommand.js";
+import { sendUnsent } from "./annotateSend.js";
 /** Terminal adapters for commands declared by Harness-owned feature plugins. */
 export function createBuiltinPluginCommandHandlers(host, openPage) {
     const handlers = new Map([
-        ['annotations:notes', async () => openPage('notes')],
-        ['annotations:annotate', async (argument) => {
+        ['annotations:open', async (argument) => {
                 const start = parseAnnotate(argument);
                 if (typeof start === 'string')
                     host.ui.notify(start, 'error');
                 else
                     await openPage('annotate', { annotate: start });
             }],
+        // The All annotations tab; no capture window opens until the person asks for one.
+        ['annotations:notes', async () => openPage('notes')],
+        ['annotations:submit', async (argument) => {
+                host.ui.notify(await sendUnsent(host.control, host.ui, { prompt: argument.trim() }), 'info');
+            }],
+        ['annotations:clear', async () => {
+                const { notes } = await host.control('terminal.annotations.clear');
+                host.ui.notify(notes.length ? `Resolved ${notes.length} unsent annotation${notes.length === 1 ? '' : 's'}; the agent can no longer read ${notes.length === 1 ? 'it' : 'them'}. Reopen from /annotate:notes.` : 'No unsent annotations to clear.', 'info');
+            }],
         ['usage:analysis', async (argument) => {
                 const period = argument.trim().toLowerCase();
                 if (period && !['today', '7d', '30d', 'all'].includes(period)) {
@@ -19,7 +28,8 @@ export function createBuiltinPluginCommandHandlers(host, openPage) {
                 }
                 await openPage('usage', { usageTab: 'analysis', ...(period ? { usagePeriod: period } : {}) });
             }],
-        ['usage:limit', async () => openPage('usage', { usageTab: 'limit' })]
+        ['usage:limit', async () => openPage('usage', { usageTab: 'limit' })],
+        ['usage:accounts', async () => openPage('usage', { usageTab: 'accounts' })]
     ]);
     const commands = BUILTIN_PLUGIN_REGISTRY.commands();
     for (const command of commands) {

package/dist/sdk/tools/defaultSkills.d.ts

@@ -0,0 +1,4 @@
+/** Locate release-owned resources from source, the SDK, or a bundled executable. */
+export declare function defaultSkillPath(): string;
+/** Variant skills win on a name collision, without modifying a pinned variant. */
+export declare function defaultSkillPaths(variantDir: string | null | undefined): string[];

package/dist/sdk/tools/defaultSkills.js

@@ -0,0 +1,20 @@
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** Locate release-owned resources from source, the SDK, or a bundled executable. */
+export function defaultSkillPath() {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (;;) {
+        const path = join(dir, 'builtin', 'skills', 'plugin-authoring', 'SKILL.md');
+        if (existsSync(path))
+            return path;
+        const parent = dirname(dir);
+        if (parent === dir)
+            throw new Error('The bundled plugin-authoring skill is missing.');
+        dir = parent;
+    }
+}
+/** Variant skills win on a name collision, without modifying a pinned variant. */
+export function defaultSkillPaths(variantDir) {
+    return variantDir && existsSync(join(variantDir, 'skills', 'plugin-authoring', 'SKILL.md')) ? [] : [defaultSkillPath()];
+}

package/dist/sdk/tools/definitions.d.ts

@@ -1,4 +1,4 @@
-export type HarnessCall = 'recall.search' | 'recall.read' | 'trajectory.search' | 'trajectory.read' | 'wiki.search' | 'wiki.read' | 'wiki.list' | 'wiki.write' | 'skill.load';
+export type HarnessCall = 'recall.search' | 'recall.read' | 'trajectory.search' | 'trajectory.read' | 'wiki.search' | 'wiki.read' | 'wiki.list' | 'wiki.write' | 'skill.load' | 'plugin.propose';
 /** A JSON Schema object, kept loose so TypeBox, MCP, and the CLI can all use it. */
 export type JsonSchema = {
     type: string;
@@ -23,6 +23,8 @@ export declare const WIKI_WRITE = "wiki_write";
 export declare const WIKI_WRITE_TOOLS: HarnessToolDefinition[];
 /** Skills: load one of this agent's skills from its harness. */
 export declare const SKILL_TOOLS: HarnessToolDefinition[];
+/** Propose a package for a person to review; this never installs or enables it. */
+export declare const PLUGIN_PROPOSAL_TOOLS: HarnessToolDefinition[];
 /** Every harness tool. */
 export declare const HARNESS_TOOLS: HarnessToolDefinition[];
 /** The harness tools every session has; `wiki_write` is added only when the caller switches it on. */

package/dist/sdk/tools/definitions.js

@@ -110,8 +110,24 @@ export const SKILL_TOOLS = [
         parameters: { type: 'object', properties: { name: text('The skill name, as your instructions write it') } }
     }
 ];
+/** Propose a package for a person to review; this never installs or enables it. */
+export const PLUGIN_PROPOSAL_TOOLS = [{
+        name: 'plugin_propose',
+        call: 'plugin.propose',
+        label: 'Propose a plugin',
+        description: 'Propose a plugin for a person to review. This does not install, enable, or trust it. Use the plugin-authoring skill first. Provide text files as a map from relative paths to their complete contents.',
+        parameters: {
+            type: 'object',
+            properties: {
+                name: text('Lowercase plugin package name, using letters, numbers, hyphens or underscores'),
+                description: text('A short description of the plugin'),
+                files: { type: 'object', additionalProperties: { type: 'string' }, description: 'Relative file paths and complete UTF-8 text contents; omit package.json' }
+            },
+            required: ['name', 'description', 'files']
+        }
+    }];
 /** Every harness tool. */
-export const HARNESS_TOOLS = [...RECALL_TOOLS, ...TRAJECTORY_TOOLS, ...WIKI_READ_TOOLS, ...WIKI_WRITE_TOOLS, ...SKILL_TOOLS];
+export const HARNESS_TOOLS = [...RECALL_TOOLS, ...TRAJECTORY_TOOLS, ...WIKI_READ_TOOLS, ...WIKI_WRITE_TOOLS, ...SKILL_TOOLS, ...PLUGIN_PROPOSAL_TOOLS];
 /** The harness tools every session has; `wiki_write` is added only when the caller switches it on. */
 export const DEFAULT_TOOL_NAMES = HARNESS_TOOLS.filter((tool) => tool.name !== WIKI_WRITE).map((tool) => tool.name);
 export const describeTool = (tool, productName) => tool.description.replaceAll('{product}', productName);

package/dist/sdk/tools/dispatch.js

@@ -7,6 +7,8 @@ import { HarnessError, invalid } from "../core/errors.js";
 import * as recall from "../history/recall.js";
 import * as trajectory from "../history/trajectory.js";
 import * as notes from "../wiki/notes.js";
+import * as proposals from "../plugins/proposals.js";
+import { defaultSkillPaths } from "./defaultSkills.js";
 function str(params, key) {
     const value = params[key];
     return typeof value === 'string' ? value : '';
@@ -45,6 +47,10 @@ export function dispatch(env, context, call, params, options = {}) {
             env.bus?.emit({ type: 'wiki.changed' });
             return `Saved ${note.path}.`;
         }
+        case 'plugin.propose': {
+            const proposal = proposals.create(env.root, params.name, params.description, params.files);
+            return `Proposed ${proposal.name} (${proposal.id}). A person can review it in the plugin manager; it is not installed or enabled.`;
+        }
         case 'skill.load':
             return loadSkill(options.variantDir ?? null, str(params, 'name'));
         default:
@@ -54,6 +60,10 @@ export function dispatch(env, context, call, params, options = {}) {
 /** A skill's text from the run's variant, or the list of its skills. */
 export function loadSkill(variantDir, name) {
     const skills = variantDir && existsSync(join(variantDir, 'skills')) ? readdirSync(join(variantDir, 'skills'), { withFileTypes: true }).filter((entry) => entry.isDirectory() && existsSync(join(variantDir, 'skills', entry.name, 'SKILL.md'))).map((entry) => entry.name).sort() : [];
+    const defaults = defaultSkillPaths(variantDir);
+    if (defaults.length)
+        skills.push('plugin-authoring');
+    skills.sort();
     const wanted = name.trim().replace(/^skills\//, '').replace(/`/g, '');
     if (!wanted)
         return skills.length ? `Your skills: ${skills.join(', ')}. Load one with skill_load and its name.` : 'You have no skills.';
@@ -61,6 +71,8 @@ export function loadSkill(variantDir, name) {
         throw invalid('A skill name is lowercase letters, digits, _ or -.');
     if (!skills.includes(wanted))
         return `There is no skill named ${wanted}.${skills.length ? ` Your skills: ${skills.join(', ')}.` : ''}`;
+    if (wanted === 'plugin-authoring' && defaults.length)
+        return readFileSync(defaults[0], 'utf8');
     const dir = join(variantDir, 'skills', wanted);
     const helpers = existsSync(join(dir, 'scripts')) ? readdirSync(join(dir, 'scripts')) : [];
     return `${readFileSync(join(dir, 'SKILL.md'), 'utf8')}${helpers.length ? `\n\n(This skill's helpers are in ${join(dir, 'scripts')}: ${helpers.join(', ')}.)` : ''}`;

package/dist/sdk/tools/harnessTools.js

@@ -6,7 +6,7 @@ export function harnessTools(env, context, options = {}) {
         label: tool.label,
         description: describeTool(tool, env.productName),
         parameters: (Type) => Type.Unsafe(tool.parameters),
-        readOnly: tool.name !== 'wiki_write',
+        readOnly: tool.name !== 'wiki_write' && tool.name !== 'plugin_propose',
         execute: async (input) => {
             try {
                 return dispatch(env, context, tool.call, input, { variantDir: options.variantDir }) || 'Nothing found.';

package/dist/sdk/tools/sessionName.d.ts

@@ -1,7 +1,16 @@
 import type { ToolSpec } from "./types.js";
 export declare const SESSION_NAME = "session_name";
+/** The trigger the prompt and the tool description share, so naming guidance cannot drift. */
+export declare const SESSION_GUIDANCE: string;
 export interface NamedSession {
     readonly sessionName?: string;
     setSessionName(name: string): void;
 }
+/** The one name validation every caller uses: a short, single-line, control-free sentence. */
+export declare function normalizeSessionName(value: unknown): string;
+/**
+ * A provisional name for a substantive first request. It is deliberately mechanical: the model
+ * can still revise it with session_name. Greetings and short conversational replies stay unnamed.
+ */
+export declare function deriveSessionName(text: string): string | null;
 export declare function sessionNameTool(current: () => NamedSession | undefined): ToolSpec;

package/dist/sdk/tools/sessionName.js

@@ -2,24 +2,71 @@
 // the current native session; it never receives a target session id from the model.
 import { invalid } from "../core/errors.js";
 export const SESSION_NAME = 'session_name';
+/** The trigger the prompt and the tool description share, so naming guidance cannot drift. */
+export const SESSION_GUIDANCE = 'If the request needs tools or changes state — not a greeting, thanks, or a short conversational reply — call session_name once before your first other tool call, naming the work from the request. ' +
+    'Use one short imperative sentence of at most six words. Revise the name only when the overall objective changes; keep the current name when it does not.';
+/** The one name validation every caller uses: a short, single-line, control-free sentence. */
+export function normalizeSessionName(value) {
+    if (typeof value !== 'string')
+        throw invalid('Send name as a short sentence of at most six words.');
+    if (/[\x00-\x08\x0e-\x1f\x7f-\x9f]/u.test(value)) {
+        throw invalid('Session names cannot contain terminal escapes or control characters.');
+    }
+    const name = value.replace(/\s+/gu, ' ').trim();
+    if (!name || name.split(' ').length > 6)
+        throw invalid('Use a non-empty session name of at most six words.');
+    return name;
+}
+const CONVERSATIONAL = /^(?:hi|hello|hey|yo|thanks|thank you|ok|okay|sure|great|nice|cool|sounds good|got it|good morning|good afternoon|good evening|how are you|what'?s up)[.!?]*$/iu;
+const LEADING = /^(?:please|can you|could you|would you|i want you to|i'd like you to|help me|let'?s|go ahead and)[,\s]+/iu;
+/**
+ * A provisional name for a substantive first request. It is deliberately mechanical: the model
+ * can still revise it with session_name. Greetings and short conversational replies stay unnamed.
+ */
+export function deriveSessionName(text) {
+    if (typeof text !== 'string')
+        return null;
+    const input = text.trim();
+    if (!input || input.startsWith('!') || input.startsWith('```') || /^https?:\/\//iu.test(input))
+        return null;
+    if (CONVERSATIONAL.test(input))
+        return null;
+    if (/^continue\b/iu.test(input))
+        return 'Continue previous work';
+    const sentence = input.split(/[.!?](?:\s|$)/u)[0] ?? input;
+    const cleaned = sentence
+        .replace(/```[\s\S]*?```/gu, ' ')
+        .replace(/[`*_~#>]/gu, ' ')
+        .replace(/[:;,]+/gu, ' ')
+        .replace(LEADING, '')
+        .replace(/\s+/gu, ' ')
+        .trim();
+    if (!/[a-z]/iu.test(cleaned))
+        return null;
+    const words = cleaned.split(' ').filter(Boolean).slice(0, 6);
+    if (!words.length)
+        return null;
+    const name = words.join(' ').replace(/^[\p{P}\p{S}]+/u, '').replace(/[\p{P}\p{S}]+$/u, '').trim();
+    if (!name)
+        return null;
+    const capitalized = name[0].toUpperCase() + name.slice(1);
+    try {
+        return normalizeSessionName(capitalized);
+    }
+    catch {
+        return null;
+    }
+}
 export function sessionNameTool(current) {
     return {
         name: SESSION_NAME,
         label: 'Name the session',
-        description: 'Set or revise this session’s name. Name meaningful work early, then revise the name when the overall objective changes; greetings alone need no name. ' +
-            'Use one short imperative sentence describing the objective, at most six words, such as "Add web browser integrations". ' +
-            'You may revise a manually assigned name. Keep a useful current name when the objective is unchanged. This only names your own session.',
+        description: `Set or revise this session’s name. ${SESSION_GUIDANCE} ` +
+            'For example, "Add web browser integrations". You may revise a manually assigned name. This only names your own session.',
         parameters: Type => Type.Object({ name: Type.String({ description: 'One short sentence describing the objective, at most six words' }) }),
         planModeSafe: () => true,
         execute: async (input) => {
-            if (typeof input.name !== 'string')
-                throw invalid('Send name as a short sentence of at most six words.');
-            if (/[\x00-\x08\x0e-\x1f\x7f-\x9f]/u.test(input.name)) {
-                throw invalid('Session names cannot contain terminal escapes or control characters.');
-            }
-            const name = input.name.replace(/\s+/gu, ' ').trim();
-            if (!name || name.split(' ').length > 6)
-                throw invalid('Use a non-empty session name of at most six words.');
+            const name = normalizeSessionName(input.name);
             const session = current();
             if (!session)
                 throw invalid('The native session is unavailable; try naming it again once it is ready.');

package/dist/sdk/tools/spawnSubagent.js

@@ -27,20 +27,22 @@ export function subagentTools(service, parentRunId) {
     return [{
             name: SPAWN_SUBAGENT,
             label: 'Start a subagent',
-            description: 'Start a fresh child run for independent work. Delegate substantial, bounded tasks that benefit from a separate context, not simple lookups, tiny edits or tightly coupled steps. Prefer a named specialist profile; omit agent only when no profile fits. Plan mode permits only eligible read-only research profiles. Give a short title and a self-contained brief: the child has no conversation history and no more capabilities than you. Returns its run ID immediately by default so you can continue other useful work. Results arrive automatically before you finish. Use wait_subagents when you need results before proceeding, or wait: true for an inline result. Avoid overlapping write assignments. Stopping you stops your children.',
+            description: 'Start a fresh child run for independent work. Delegate substantial, bounded tasks that benefit from a separate context, not simple lookups, tiny edits or tightly coupled steps. Prefer a named specialist profile; omit agent only when no profile fits. Plan mode permits only eligible read-only research profiles. Give a short title and a self-contained brief: the child has no conversation history and no more capabilities than you. The optional tools field only narrows the profile and parent intersection; in plan mode, omit it unless you need a stricter subset. Returns its run ID immediately by default so you can continue other useful work. Results arrive automatically before you finish. Use wait_subagents when you need results before proceeding, or wait: true for an inline result. Avoid overlapping write assignments. Stopping you stops your children. To resume a child that stopped before finishing (interrupted or failed), pass continue with its run ID and no title, agent or tools: it reopens that child\'s own conversation with the same profile and tools, and brief becomes an optional extra instruction.',
             planModeSafe: input => service.planSpawnRefusal(parentRunId, input) === null,
             parameters: (Type) => Type.Object({
-                title: Type.String({ description: `A short imperative title for the roster, at most ${MAX_SUBAGENT_TITLE_WORDS} words, such as "Map the auth flow"` }),
-                brief: Type.String({ description: 'A self-contained task: goal, relevant context or paths, non-goals, expected result, and acceptance or verification. The child cannot see this conversation.' }),
+                title: Type.Optional(Type.String({ description: `Required for a new child: a short imperative title for the roster, at most ${MAX_SUBAGENT_TITLE_WORDS} words, such as "Map the auth flow"` })),
+                brief: Type.Optional(Type.String({ description: 'Required for a new child: a self-contained task: goal, relevant context or paths, non-goals, expected result, and acceptance or verification. The child cannot see this conversation. With continue, an optional extra instruction.' })),
+                continue: Type.Optional(Type.String({ description: 'The run ID of one of your subagents that stopped before finishing, to continue it from where it stopped instead of starting a fresh child' })),
                 agent: Type.Optional(Type.String({ description: 'The name of a specialist profile from your Subagents list; omit only when no listed profile fits (omitting starts an unprofiled copy)' })),
-                tools: Type.Optional(Type.Array(Type.String())),
+                tools: Type.Optional(Type.Array(Type.String({ description: 'Only request a stricter subset of the profile and parent tools. In plan mode, omit this field to inherit the safe available research intersection.' }))),
                 wait: Type.Optional(Type.Boolean({ description: 'Wait for the child and return its result; default false' }))
             }),
             execute: execute(async (input) => {
-                const title = subagentTitle(input.title);
-                if (!title)
+                const resume = input.continue === undefined ? undefined : input.continue;
+                const title = resume === undefined ? subagentTitle(input.title) : undefined;
+                if (resume === undefined && !title)
                     throw invalid(`Give the subagent a title of at most ${MAX_SUBAGENT_TITLE_WORDS} words, with no control characters.`);
-                const child = await service.spawn({ parentRunId, brief: input.brief, title, agent: input.agent, tools: input.tools, wait: input.wait });
+                const child = await service.spawn({ parentRunId, brief: input.brief, title, agent: input.agent, tools: input.tools, wait: input.wait, ...(resume === undefined ? {} : { continue: resume }) });
                 if (input.wait === true)
                     return reported(parentRunId, service.results({ parentRunId, runIds: [child.runId] }), [child.runId]);
                 return { text: JSON.stringify(child), details: { [SUBAGENT_RECEIPT]: { version: 1, ownerRunId: parentRunId, spawned: [child.runId] } } };

package/dist/sdk/tools/todo.d.ts

@@ -0,0 +1,15 @@
+import { type TodoItem, type RunEvent } from "../sessions/contracts.js";
+import type { ActiveRun } from "../sessions/registry.js";
+import type { ToolSpec } from "./types.js";
+export declare const TODO_WRITE = "todo_write";
+/** The trigger the prompt and the tool description share, so progress guidance cannot drift. */
+export declare const TODO_GUIDANCE: string;
+/** The todo list as the model reads it back. */
+export declare function describeTodo(items: readonly TodoItem[]): string;
+/** The latest todo list a run wrote, or an empty list. Reads the pre-rename event too. */
+export declare function todoOf(events: readonly RunEvent[]): TodoItem[];
+export declare function todoTool(run: Pick<ActiveRun, 'emit'>): ToolSpec;
+/** @deprecated Use `TODO_WRITE`; kept for one release so embedders can migrate. */
+export declare const CHECKLIST_WRITE = "todo_write";
+/** @deprecated Use `todoOf`; kept for one release so embedders can migrate. */
+export declare const checklistOf: typeof todoOf;

package/dist/sdk/tools/todo.js

@@ -0,0 +1,64 @@
+// The run's own todo list: the model writes the whole list each time, and the run records it as
+// a `todo.updated` event. It only changes run state, so it stays callable in plan mode.
+import { todoItemSchema, MAX_TODO_ITEMS } from "../sessions/contracts.js";
+export const TODO_WRITE = 'todo_write';
+/** The trigger the prompt and the tool description share, so progress guidance cannot drift. */
+export const TODO_GUIDANCE = 'If the work has several distinct steps or will take more than one tool call, call todo_write before your first other tool call with the steps you know so far, and keep the list current as steps start and finish. ' +
+    'Before your final reply, write one final update: mark every fully completed step completed and leave unfinished or blocked steps accurate. Never mark unfinished work completed. ' +
+    'The person follows your work from it, and a subagent’s todo list shows as its progress in the person’s list of subagents.';
+/** The event a run writes; `checklist.updated` is the pre-rename name, still read for old runs. */
+const TODO_EVENTS = new Set(['todo.updated', 'checklist.updated']);
+const MARK = { pending: '[ ]', in_progress: '[~]', completed: '[x]' };
+/** The todo list as the model reads it back. */
+export function describeTodo(items) {
+    if (!items.length)
+        return 'The todo list is empty.';
+    return items.map((item) => `${MARK[item.status]} ${item.text}`).join('\n');
+}
+/** The latest todo list a run wrote, or an empty list. Reads the pre-rename event too. */
+export function todoOf(events) {
+    const last = events.filter((event) => TODO_EVENTS.has(event.type)).at(-1);
+    const items = last?.payload?.items;
+    return Array.isArray(items) ? items.flatMap((item) => {
+        const parsed = todoItemSchema.safeParse(item);
+        return parsed.success ? [parsed.data] : [];
+    }) : [];
+}
+export function todoTool(run) {
+    return {
+        name: TODO_WRITE,
+        label: 'Write the todo list',
+        description: `Keep a todo list of the steps of the current work. The user watches this list to follow your progress. ${TODO_GUIDANCE} ` +
+            'Send the whole list every time; it replaces the previous one. Do not use it for a single, simple step or for conversation. ' +
+            'Statuses: pending, in_progress, completed. Keep exactly one step in_progress while you work, mark a step completed as soon as it is done (not in batches), and add steps you discover. ' +
+            'Only mark a step completed when it is fully done; if something blocks it, keep it in_progress and add a step for the blocker.',
+        parameters: (Type) => Type.Object({
+            items: Type.Array(Type.Object({
+                text: Type.String({ description: 'One step, as a short imperative line' }),
+                status: Type.Union([Type.Literal('pending'), Type.Literal('in_progress'), Type.Literal('completed')])
+            }), { maxItems: MAX_TODO_ITEMS })
+        }),
+        readOnly: true,
+        planModeSafe: () => true,
+        execute: async (input) => {
+            if (!Array.isArray(input.items))
+                return 'Send items: the whole todo list as an array.';
+            if (input.items.length > MAX_TODO_ITEMS)
+                return `Keep the todo list to ${MAX_TODO_ITEMS} steps or fewer.`;
+            const items = [];
+            for (const raw of input.items) {
+                const entry = raw;
+                const parsed = todoItemSchema.safeParse({ text: typeof entry?.text === 'string' ? entry.text.trim() : entry?.text, status: entry?.status });
+                if (!parsed.success)
+                    return 'Every step needs text of 1 to 500 characters and a status of pending, in_progress or completed.';
+                items.push(parsed.data);
+            }
+            run.emit('todo.updated', { items });
+            return describeTodo(items);
+        }
+    };
+}
+/** @deprecated Use `TODO_WRITE`; kept for one release so embedders can migrate. */
+export const CHECKLIST_WRITE = TODO_WRITE;
+/** @deprecated Use `todoOf`; kept for one release so embedders can migrate. */
+export const checklistOf = todoOf;

package/dist/sdk/world/world.d.ts

@@ -27,8 +27,6 @@ export interface WorldOptions {
     request?: WebRequest;
     /** Replaces the browser's launcher and address check in tests. */
     browser?: Omit<BrowserPartOptions, 'stateDir'> | false;
-    /** Told when the agent marks a page note fixed, so front ends refresh (PROP-0018). */
-    notesChanged?: (sessionId: string | null, ids: string[]) => void;
 }
 /** A family of world tools, switched as one plugin. */
 export interface WorldPart {