dominds 1.27.2 → 1.27.4

package/dist/runtime/shared-reminder-update-impact.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchSharedReminderUpdateImpact = dispatchSharedReminderUpdateImpact;
+exports.dispatchSharedReminderMigrationImpact = dispatchSharedReminderMigrationImpact;
+const id_1 = require("@longrun-ai/kernel/utils/id");
+const dialog_global_registry_1 = require("../dialog-global-registry");
+const driver_messages_1 = require("./driver-messages");
+function sharedReminderUpdateImpactsDialog(args) {
+    if (args.candidate.id.equals(args.updater.id)) {
+        return false;
+    }
+    if (args.candidate.agentId !== args.updater.agentId) {
+        return false;
+    }
+    return args.scope === 'task' ? args.candidate.taskDocPath === args.updater.taskDocPath : true;
+}
+function collectSharedReminderUpdatePeerDialogs(args) {
+    const peers = [];
+    for (const candidate of dialog_global_registry_1.globalDialogRegistry.getLoadedInFlightDialogsForSharedReminderImpact()) {
+        if (sharedReminderUpdateImpactsDialog({
+            scope: args.scope,
+            updater: args.updater,
+            candidate,
+        })) {
+            peers.push(candidate);
+        }
+    }
+    return peers;
+}
+async function queueSharedReminderUpdateImpactPrompt(args) {
+    await args.targetDialog.queueRuntimeGuidePrompt({
+        prompt: (0, driver_messages_1.formatSharedReminderUpdateImpactNotice)(args.language, {
+            reminderId: args.reminderId,
+            scope: args.scope,
+            audience: 'peer',
+        }),
+        msgId: (0, id_1.generateShortId)(),
+        grammar: 'markdown',
+        userLanguageCode: args.language,
+        skipTaskdoc: true,
+    });
+    dialog_global_registry_1.globalDialogRegistry.queueRootDrive(args.targetDialog.id.rootId, {
+        source: 'shared_reminder_update_impact',
+        reason: `reminder_id:${args.reminderId}`,
+    });
+}
+async function queueSharedReminderMigrationImpactPrompt(args) {
+    await args.targetDialog.queueRuntimeGuidePrompt({
+        prompt: (0, driver_messages_1.formatSharedReminderMigrationImpactNotice)(args.language, {
+            reminderId: args.reminderId,
+            scope: args.scope,
+        }),
+        msgId: (0, id_1.generateShortId)(),
+        grammar: 'markdown',
+        userLanguageCode: args.language,
+        skipTaskdoc: true,
+    });
+    dialog_global_registry_1.globalDialogRegistry.queueRootDrive(args.targetDialog.id.rootId, {
+        source: 'shared_reminder_migration_impact',
+        reason: `migrated_reminder_id:${args.reminderId}`,
+    });
+}
+async function dispatchSharedReminderUpdateImpact(args) {
+    const peerDialogs = collectSharedReminderUpdatePeerDialogs({
+        updater: args.updater,
+        scope: args.scope,
+    });
+    if (peerDialogs.length === 0) {
+        return undefined;
+    }
+    let dispatchedDialogCount = 0;
+    for (const peerDialog of peerDialogs) {
+        await queueSharedReminderUpdateImpactPrompt({
+            targetDialog: peerDialog,
+            reminderId: args.reminderId,
+            scope: args.scope,
+            language: args.language,
+        });
+        dispatchedDialogCount += 1;
+    }
+    return {
+        scope: args.scope,
+        peerDialogCount: peerDialogs.length,
+        dispatchedDialogCount,
+    };
+}
+async function dispatchSharedReminderMigrationImpact(args) {
+    const peerDialogs = collectSharedReminderUpdatePeerDialogs({
+        updater: args.updater,
+        scope: args.scope,
+    });
+    if (peerDialogs.length === 0) {
+        return undefined;
+    }
+    let dispatchedDialogCount = 0;
+    for (const peerDialog of peerDialogs) {
+        await queueSharedReminderMigrationImpactPrompt({
+            targetDialog: peerDialog,
+            reminderId: args.reminderId,
+            scope: args.scope,
+            language: args.language,
+        });
+        dispatchedDialogCount += 1;
+    }
+    return {
+        scope: args.scope,
+        peerDialogCount: peerDialogs.length,
+        dispatchedDialogCount,
+    };
+}

package/dist/shared-reminders.js

@@ -106,8 +106,8 @@ function serializeReminder(reminder) {
         ownerName: reminder.owner?.name,
         meta: reminder.meta,
         echoback: reminder.echoback,
-        scope: reminder.scope ?? 'agent',
-        renderMode: reminder.renderMode ?? 'markdown',
+        scope: reminder.scope,
+        renderMode: reminder.renderMode,
         createdAt: reminder.createdAt ?? (0, time_1.formatUnifiedTimestamp)(new Date()),
         priority: reminder.priority ?? 'medium',
     };

package/dist/tool-availability.js

@@ -225,6 +225,7 @@ function buildIntrinsicControlToolset(dialog) {
         ctrl_1.addReminderTool,
         ctrl_1.deleteReminderTool,
         ctrl_1.updateReminderTool,
+        ctrl_1.migrateReminderTool,
         ctrl_1.clearMindTool,
         ctrl_1.recallTaskdocTool,
     ];

package/dist/tool.d.ts

@@ -50,7 +50,11 @@ type PreparedRawToolArguments = Readonly<{
 }>;
 export interface ReminderOptions {
     readonly echoback?: boolean;
-    readonly scope?: ReminderScope;
+    readonly scope: ReminderScope;
+    readonly renderMode: ReminderRenderMode;
+}
+export interface ReminderUpdateOptions {
+    readonly echoback?: boolean;
     readonly renderMode?: ReminderRenderMode;
 }
 export type ReminderScope = 'dialog' | 'task' | 'agent' | 'runtime';
@@ -63,7 +67,6 @@ export interface Reminder extends ReminderOptions {
     readonly meta?: JsonValue;
     readonly createdAt?: string;
     readonly priority?: ReminderPriority;
-    readonly renderMode?: ReminderRenderMode;
 }
 export declare function reminderEchoBackEnabled(reminder: Reminder): boolean;
 export declare function reminderIsVirtual(reminder: Reminder): boolean;
@@ -75,10 +78,10 @@ export declare function materializeReminder(input: Readonly<{
     owner?: ReminderOwner;
     meta?: JsonValue;
     echoback?: boolean;
-    scope?: ReminderScope;
+    scope: ReminderScope;
     createdAt?: string;
     priority?: ReminderPriority;
-    renderMode?: ReminderRenderMode;
+    renderMode: ReminderRenderMode;
 }>): Reminder;
 export declare function cloneReminder(reminder: Reminder): Reminder;
 export declare function computeReminderRenderRevision(reminder: Reminder): string;

package/dist/tool.js

@@ -63,16 +63,22 @@ function ensureReminderId(value) {
     return trimmed && trimmed.length > 0 ? trimmed : generateReminderId();
 }
 function materializeReminder(input) {
+    if (input.scope === undefined) {
+        throw new Error('materializeReminder requires explicit scope');
+    }
+    if (input.renderMode === undefined) {
+        throw new Error('materializeReminder requires explicit renderMode');
+    }
     return {
         id: ensureReminderId(input.id),
         content: input.content,
         owner: input.owner,
         meta: input.meta,
         echoback: input.echoback,
-        scope: input.scope ?? 'dialog',
+        scope: input.scope,
         createdAt: input.createdAt,
         priority: input.priority,
-        renderMode: input.renderMode ?? 'markdown',
+        renderMode: input.renderMode,
     };
 }
 function cloneReminder(reminder) {
@@ -94,8 +100,8 @@ function computeReminderRenderRevision(reminder) {
         content: reminder.content,
         meta: reminder.meta ?? null,
         echoback: reminder.echoback ?? true,
-        scope: reminder.scope ?? 'dialog',
-        renderMode: reminder.renderMode ?? 'markdown',
+        scope: reminder.scope,
+        renderMode: reminder.renderMode,
     });
     return `sha256:${(0, crypto_1.createHash)('sha256').update(payload, 'utf8').digest('hex')}`;
 }

package/dist/tools/app-reminders.js

@@ -139,7 +139,7 @@ function toReminderState(reminder) {
         content: reminder.content,
         meta: extractOwnerMeta(reminder.meta),
         echoback: reminder.echoback,
-        renderMode: reminder.renderMode ?? 'markdown',
+        renderMode: reminder.renderMode,
     };
 }
 function findOwnedReminderEntries(dlg, descriptor, owner) {
@@ -201,7 +201,7 @@ async function persistAndPublishReminders(dlg) {
         renderRevision: (0, tool_1.computeReminderRenderRevision)(reminder),
         echoback: (0, tool_1.reminderEchoBackEnabled)(reminder),
         scope: reminder.scope,
-        renderMode: reminder.renderMode ?? 'markdown',
+        renderMode: reminder.renderMode,
     }));
     const evt = { type: 'full_reminders_update', reminders };
     (0, evt_registry_1.postDialogEvent)(dlg, evt);
@@ -321,6 +321,7 @@ async function applyAppReminderRequests(dlg, params) {
             case 'add': {
                 dlg.addReminder(result.reminder.content, owner, buildAppReminderMeta(descriptor, result.reminder.meta), normalizeInsertPosition(dlg.reminders.length, result.position), {
                     echoback: result.reminder.echoback,
+                    scope: 'dialog',
                     renderMode: result.reminder.renderMode ?? 'markdown',
                 });
                 changed = true;
@@ -334,7 +335,7 @@ async function applyAppReminderRequests(dlg, params) {
                 dlg.updateReminder(target.index, result.reminder.content, buildAppReminderMeta(descriptor, result.reminder.meta), {
                     echoback: result.reminder.echoback,
                     // Preserve the existing render mode when the app does not explicitly override it.
-                    renderMode: result.reminder.renderMode ?? target.reminder.renderMode ?? 'markdown',
+                    renderMode: result.reminder.renderMode ?? target.reminder.renderMode,
                 });
                 changed = true;
                 break;

package/dist/tools/builtins.js

@@ -118,6 +118,7 @@ function manualSpecFor(toolsetId) {
 (0, registry_1.registerTool)(ctrl_1.addReminderTool);
 (0, registry_1.registerTool)(ctrl_1.deleteReminderTool);
 (0, registry_1.registerTool)(ctrl_1.updateReminderTool);
+(0, registry_1.registerTool)(ctrl_1.migrateReminderTool);
 (0, registry_1.registerTool)(ctrl_1.clearMindTool);
 (0, registry_1.registerTool)(ctrl_1.doMindTool);
 (0, registry_1.registerTool)(ctrl_1.changeMindTool);
@@ -190,6 +191,7 @@ for (const tool of team_mgmt_1.teamMgmtTools) {
     ctrl_1.addReminderTool,
     ctrl_1.deleteReminderTool,
     ctrl_1.updateReminderTool,
+    ctrl_1.migrateReminderTool,
     ctrl_1.clearMindTool,
     ctrl_1.doMindTool,
     ctrl_1.changeMindTool,

package/dist/tools/cmd-runner-protocol.d.ts

@@ -1,3 +1,4 @@
+export declare const MAX_CMD_RUNNER_OUTPUT_WAIT_TIMEOUT_MS: number;
 export type CmdRunnerSpawnSpec = Readonly<{
     command: string;
     args: string[];
@@ -38,6 +39,8 @@ export type CmdRunnerRequest = Readonly<{
     type: 'get_output';
     stdout: boolean;
     stderr: boolean;
+    waitForNewOutput: boolean;
+    timeoutMs?: number;
 }> | Readonly<{
     type: 'stop';
     entirePg: boolean;
@@ -45,7 +48,9 @@ export type CmdRunnerRequest = Readonly<{
 export type CmdRunnerStreamSnapshot = Readonly<{
     content: string;
     linesScrolledOut: number;
+    version: number;
 }>;
+export type CmdRunnerOutputWaitStatus = 'output' | 'timeout' | 'exited';
 export type CmdRunnerStatusPayload = Readonly<{
     daemonPid: number;
     daemonCommandLine: string;
@@ -69,6 +74,7 @@ export type CmdRunnerResponse = (Readonly<{
 }> & CmdRunnerStatusPayload) | (Readonly<{
     type: 'output';
     ok: true;
+    waitStatus?: CmdRunnerOutputWaitStatus;
 }> & CmdRunnerStatusPayload) | (Readonly<{
     type: 'stop_result';
     ok: true;

package/dist/tools/cmd-runner-protocol.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_CMD_RUNNER_OUTPUT_WAIT_TIMEOUT_MS = void 0;
 exports.parseCmdRunnerInitMessage = parseCmdRunnerInitMessage;
 exports.parseCmdRunnerInitialIpcMessage = parseCmdRunnerInitialIpcMessage;
 exports.parseCmdRunnerRequestLine = parseCmdRunnerRequestLine;
@@ -10,6 +11,7 @@ exports.parseCmdRunnerResponseLine = parseCmdRunnerResponseLine;
 exports.getCmdRunnerEndpointForDaemonPid = getCmdRunnerEndpointForDaemonPid;
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
+exports.MAX_CMD_RUNNER_OUTPUT_WAIT_TIMEOUT_MS = 24 * 60 * 60 * 1_000;
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -33,13 +35,39 @@ function parseStreamSnapshot(raw, label) {
     }
     const content = asString(raw['content']);
     const linesScrolledOut = asNumber(raw['linesScrolledOut']);
+    const version = asNumber(raw['version']);
     if (content === null) {
         throw new Error(`Invalid cmd_runner ${label}.content: expected string`);
     }
     if (linesScrolledOut === null) {
         throw new Error(`Invalid cmd_runner ${label}.linesScrolledOut: expected number`);
     }
-    return { content, linesScrolledOut };
+    if (version === null) {
+        throw new Error(`Invalid cmd_runner ${label}.version: expected number`);
+    }
+    return { content, linesScrolledOut, version };
+}
+function parseOptionalTimeoutMs(raw, label) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    const value = asNumber(raw);
+    if (value === null ||
+        !Number.isInteger(value) ||
+        value < 0 ||
+        value > exports.MAX_CMD_RUNNER_OUTPUT_WAIT_TIMEOUT_MS) {
+        throw new Error(`Invalid cmd_runner ${label}: expected non-negative integer <= ${String(exports.MAX_CMD_RUNNER_OUTPUT_WAIT_TIMEOUT_MS)}`);
+    }
+    return value;
+}
+function parseOutputWaitStatus(raw) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    if (raw === 'output' || raw === 'timeout' || raw === 'exited') {
+        return raw;
+    }
+    throw new Error(`Invalid cmd_runner output waitStatus: ${String(raw)}`);
 }
 function parseStatusPayload(raw) {
     const daemonPid = asNumber(raw['daemonPid']);
@@ -239,10 +267,28 @@ function parseCmdRunnerRequestLine(line) {
     if (type === 'get_output') {
         const stdout = asBoolean(raw['stdout']);
         const stderr = asBoolean(raw['stderr']);
+        const waitForNewOutputRaw = raw['waitForNewOutput'];
+        const waitForNewOutput = waitForNewOutputRaw === undefined ? false : asBoolean(waitForNewOutputRaw);
+        const timeoutMs = parseOptionalTimeoutMs(raw['timeoutMs'], 'get_output.timeoutMs');
         if (stdout === null || stderr === null) {
             throw new Error('Invalid cmd_runner get_output request: stdout/stderr must be boolean');
         }
-        return { type, stdout, stderr };
+        if (waitForNewOutput === null) {
+            throw new Error('Invalid cmd_runner get_output request: waitForNewOutput must be boolean');
+        }
+        if (!stdout && !stderr) {
+            throw new Error('Invalid cmd_runner get_output request: at least one stream is required');
+        }
+        if (!waitForNewOutput && timeoutMs !== undefined) {
+            throw new Error('Invalid cmd_runner get_output request: timeoutMs requires waitForNewOutput=true');
+        }
+        return {
+            type,
+            stdout,
+            stderr,
+            waitForNewOutput,
+            ...(timeoutMs === undefined ? {} : { timeoutMs }),
+        };
     }
     throw new Error(`Invalid cmd_runner request type: ${String(type)}`);
 }
@@ -269,6 +315,15 @@ function parseCmdRunnerResponseLine(line) {
     if (type !== 'pong' && type !== 'status' && type !== 'output' && type !== 'stop_result') {
         throw new Error(`Invalid cmd_runner response type: ${String(type)}`);
     }
+    if (type === 'output') {
+        const waitStatus = parseOutputWaitStatus(raw['waitStatus']);
+        return {
+            type,
+            ok: true,
+            ...(waitStatus === undefined ? {} : { waitStatus }),
+            ...parseStatusPayload(raw),
+        };
+    }
     return {
         type,
         ok: true,

package/dist/tools/cmd-runner.js

@@ -17,10 +17,15 @@ class ScrollingBuffer {
     maxLines;
     lines = [];
     linesScrolledOut = 0;
+    version = 0;
     constructor(maxLines) {
         this.maxLines = maxLines;
     }
     addText(text) {
+        if (text.length === 0) {
+            return;
+        }
+        this.version += 1;
         const newLines = text.split('\n');
         if (newLines[newLines.length - 1] === '') {
             newLines.pop();
@@ -37,8 +42,12 @@ class ScrollingBuffer {
         return {
             content: this.lines.join('\n'),
             linesScrolledOut: this.linesScrolledOut,
+            version: this.version,
         };
     }
+    getVersion() {
+        return this.version;
+    }
 }
 async function flushIpc(msg) {
     const send = process.send;
@@ -177,6 +186,64 @@ async function main() {
     let closeRequested = false;
     let timeoutHandle;
     let initialResultSent = false;
+    const outputWaiters = [];
+    const requestedOutputChanged = (waiter) => (waiter.stdout && state.stdout.getVersion() !== waiter.initialStdoutVersion) ||
+        (waiter.stderr && state.stderr.getVersion() !== waiter.initialStderrVersion);
+    const removeOutputWaiter = (waiter) => {
+        const index = outputWaiters.indexOf(waiter);
+        if (index !== -1) {
+            outputWaiters.splice(index, 1);
+        }
+    };
+    const settleOutputWaiter = (waiter, status) => {
+        removeOutputWaiter(waiter);
+        if (waiter.timeoutHandle !== undefined) {
+            clearTimeout(waiter.timeoutHandle);
+        }
+        waiter.resolve(status);
+    };
+    const notifyOutputWaiters = () => {
+        for (const waiter of [...outputWaiters]) {
+            if (requestedOutputChanged(waiter)) {
+                settleOutputWaiter(waiter, 'output');
+                continue;
+            }
+            if (!state.isRunning) {
+                settleOutputWaiter(waiter, 'exited');
+            }
+        }
+    };
+    const waitForRequestedNewOutput = async (request, socket) => {
+        if (!state.isRunning) {
+            return 'exited';
+        }
+        return await new Promise((resolve) => {
+            let waiter;
+            const onSocketClosed = () => {
+                if (waiter !== undefined) {
+                    settleOutputWaiter(waiter, 'client_closed');
+                }
+            };
+            waiter = {
+                stdout: request.stdout,
+                stderr: request.stderr,
+                initialStdoutVersion: state.stdout.getVersion(),
+                initialStderrVersion: state.stderr.getVersion(),
+                resolve: (status) => {
+                    socket.off('close', onSocketClosed);
+                    resolve(status);
+                },
+            };
+            if (request.timeoutMs !== undefined) {
+                waiter.timeoutHandle = setTimeout(() => {
+                    settleOutputWaiter(waiter, 'timeout');
+                }, request.timeoutMs);
+            }
+            socket.once('close', onSocketClosed);
+            outputWaiters.push(waiter);
+            notifyOutputWaiters();
+        });
+    };
     const tryFlushInitialResult = async (msg) => {
         if (initialResultSent) {
             return false;
@@ -262,6 +329,7 @@ async function main() {
         state.isRunning = false;
         state.exitCode = code;
         state.exitSignal = signal;
+        notifyOutputWaiters();
         void (async () => {
             if (state.daemonCommandLine === null && !initialResultSent) {
                 await tryFlushInitialResult({
@@ -292,9 +360,11 @@ async function main() {
     });
     stdout.on('data', (data) => {
         state.stdout.addText(data.toString());
+        notifyOutputWaiters();
     });
     stderr.on('data', (data) => {
         state.stderr.addText(data.toString());
+        notifyOutputWaiters();
     });
     await ensureSocketParentDir(endpoint);
     if (closeRequested) {
@@ -331,13 +401,24 @@ async function main() {
                         return;
                     }
                     if (request.type === 'get_output') {
+                        const waitStatus = request.waitForNewOutput
+                            ? await waitForRequestedNewOutput(request, socket)
+                            : undefined;
+                        if (waitStatus === 'client_closed') {
+                            return;
+                        }
                         const payload = buildStatusPayload(state);
                         writeSocketResponse(socket, {
                             type: 'output',
                             ok: true,
+                            ...(waitStatus === undefined ? {} : { waitStatus }),
                             ...payload,
-                            stdout: request.stdout ? payload.stdout : { content: '', linesScrolledOut: 0 },
-                            stderr: request.stderr ? payload.stderr : { content: '', linesScrolledOut: 0 },
+                            stdout: request.stdout
+                                ? payload.stdout
+                                : { content: '', linesScrolledOut: 0, version: 0 },
+                            stderr: request.stderr
+                                ? payload.stderr
+                                : { content: '', linesScrolledOut: 0, version: 0 },
                         });
                         return;
                     }

package/dist/tools/ctrl.d.ts

@@ -12,6 +12,7 @@
  * - add_reminder: Add a reminder
  * - delete_reminder: Delete a reminder by id
  * - update_reminder: Update reminder content
+ * - migrate_reminder: Move a visible shared reminder back into the current dialog
  * - clear_mind: Start a new course, optionally add a reminder
  * - do_mind: Main Dialog only; create a new `.tsk/` Taskdoc section without starting a new course
  * - change_mind: Main Dialog only; update a `.tsk/` Taskdoc section without starting a new course
@@ -32,6 +33,7 @@ import { type FuncTool } from '../tool';
 export declare const deleteReminderTool: FuncTool;
 export declare const addReminderTool: FuncTool;
 export declare const updateReminderTool: FuncTool;
+export declare const migrateReminderTool: FuncTool;
 export declare const clearMindTool: FuncTool;
 export declare const changeMindTool: FuncTool;
 export declare const doMindTool: FuncTool;