dominds 1.4.2 → 1.5.2

package/dist/priming.js

@@ -19,7 +19,9 @@ const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
 const yaml_1 = __importDefault(require("yaml"));
 const persistence_1 = require("./persistence");
+const storage_1 = require("./shared/types/storage");
 const time_1 = require("./shared/utils/time");
+const registry_1 = require("./tools/registry");
 const PRIMING_ROOT_DIR = path_1.default.resolve(process.cwd(), '.minds', 'priming');
 const PRIMING_INDIVIDUAL_DIR = path_1.default.resolve(PRIMING_ROOT_DIR, 'individual');
 const PRIMING_TEAM_SHARED_DIR = path_1.default.resolve(PRIMING_ROOT_DIR, 'team_shared');
@@ -28,6 +30,21 @@ const RECENT_PRIMING_MAX = 20;
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+function isJsonValue(value) {
+    if (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return true;
+    }
+    if (Array.isArray(value)) {
+        return value.every((item) => isJsonValue(item));
+    }
+    if (!isRecord(value)) {
+        return false;
+    }
+    return Object.values(value).every((item) => isJsonValue(item));
+}
 function ensureInside(basePath, candidatePath) {
     const normalizedBase = basePath.endsWith(path_1.default.sep) ? basePath : `${basePath}${path_1.default.sep}`;
     const resolved = path_1.default.resolve(candidatePath);
@@ -136,6 +153,96 @@ function parseApplicableMemberIds(frontmatter) {
     }
     return deduped.length > 0 ? deduped : undefined;
 }
+function parseReminderPriority(value, context) {
+    if (value === undefined)
+        return undefined;
+    if (value === 'high' || value === 'medium' || value === 'low')
+        return value;
+    throw new Error(`${context}.priority must be high | medium | low when provided`);
+}
+function parseReminderSnapshots(frontmatter) {
+    const raw = frontmatter['reminders'];
+    if (raw === undefined)
+        return undefined;
+    if (!Array.isArray(raw)) {
+        throw new Error('top-level frontmatter.reminders must be an array when provided');
+    }
+    const reminders = [];
+    for (let index = 0; index < raw.length; index += 1) {
+        const item = raw[index];
+        const context = `frontmatter.reminders[${String(index)}]`;
+        if (!isRecord(item)) {
+            throw new Error(`${context} must be an object`);
+        }
+        const content = typeof item['content'] === 'string'
+            ? item['content']
+            : (() => {
+                throw new Error(`${context}.content must be a string`);
+            })();
+        if (content.trim() === '') {
+            throw new Error(`${context}.content must be a non-empty string`);
+        }
+        const ownerName = item['ownerName'];
+        if (ownerName !== undefined && (typeof ownerName !== 'string' || ownerName.trim() === '')) {
+            throw new Error(`${context}.ownerName must be a non-empty string when provided`);
+        }
+        const meta = item['meta'];
+        if (meta !== undefined && !isJsonValue(meta)) {
+            throw new Error(`${context}.meta must be valid JSON-compatible data when provided`);
+        }
+        const echoback = item['echoback'];
+        if (echoback !== undefined && typeof echoback !== 'boolean') {
+            throw new Error(`${context}.echoback must be a boolean when provided`);
+        }
+        const createdAt = item['createdAt'];
+        if (createdAt !== undefined && typeof createdAt !== 'string') {
+            throw new Error(`${context}.createdAt must be a string when provided`);
+        }
+        const priority = parseReminderPriority(item['priority'], context);
+        reminders.push({
+            content,
+            ownerName: typeof ownerName === 'string' ? ownerName.trim() : undefined,
+            meta,
+            echoback,
+            createdAt: typeof createdAt === 'string' ? createdAt : undefined,
+            priority,
+        });
+    }
+    return reminders;
+}
+function reminderToSnapshot(reminder) {
+    const persistedReminder = reminder;
+    return {
+        content: reminder.content,
+        ownerName: reminder.owner?.name,
+        meta: reminder.meta,
+        echoback: reminder.echoback,
+        createdAt: persistedReminder.createdAt,
+        priority: persistedReminder.priority,
+    };
+}
+function materializeReminderSnapshot(snapshot, context) {
+    const owner = snapshot.ownerName === undefined
+        ? undefined
+        : (() => {
+            const resolved = (0, registry_1.getReminderOwner)(snapshot.ownerName);
+            if (!resolved) {
+                throw new Error(`${context}.ownerName '${snapshot.ownerName}' is not registered`);
+            }
+            return resolved;
+        })();
+    const reminder = {
+        content: snapshot.content,
+        owner,
+        meta: snapshot.meta,
+        echoback: snapshot.echoback,
+    };
+    if (snapshot.createdAt !== undefined)
+        reminder.createdAt = snapshot.createdAt;
+    if (snapshot.priority !== undefined)
+        reminder.priority = snapshot.priority;
+    return reminder;
+}
 function isPrimingRecordType(raw) {
     return (raw === 'agent_thought_record' ||
         raw === 'agent_words_record' ||
@@ -618,8 +725,9 @@ function normalizePrimingRecordFromJson(raw) {
                 result: expectStringField(raw, 'result', context, true),
                 callId: expectStringField(raw, 'callId', context),
             };
-            if (callingGenseq !== undefined)
-                record.calling_genseq = callingGenseq;
+            if (callingGenseq !== undefined) {
+                record.calling_genseq = (0, storage_1.toCallingGenerationSeqNumber)(callingGenseq);
+            }
             if (mentionList)
                 record.mentionList = mentionList;
             if (sourceTag)
@@ -646,14 +754,17 @@ function normalizePrimingRecordFromJson(raw) {
                 callId: expectStringField(raw, 'callId', context),
                 genseq: expectIntegerField(raw, 'genseq', context),
             };
-            if (assignmentCourse !== undefined)
-                record.assignmentCourse = assignmentCourse;
-            if (assignmentGenseq !== undefined)
-                record.assignmentGenseq = assignmentGenseq;
+            if (assignmentCourse !== undefined) {
+                record.assignmentCourse = (0, storage_1.toAssignmentCourseNumber)(assignmentCourse);
+            }
+            if (assignmentGenseq !== undefined) {
+                record.assignmentGenseq = (0, storage_1.toAssignmentGenerationSeqNumber)(assignmentGenseq);
+            }
             if (callerDialogId !== undefined)
                 record.callerDialogId = callerDialogId;
-            if (callerCourse !== undefined)
-                record.callerCourse = callerCourse;
+            if (callerCourse !== undefined) {
+                record.callerCourse = (0, storage_1.toCallerCourseNumber)(callerCourse);
+            }
             if (sourceTag)
                 record.sourceTag = sourceTag;
             const { ts: _unusedTs, ...withoutTs } = record;
@@ -735,14 +846,17 @@ function normalizePrimingRecordFromJson(raw) {
                     }
                 }
             })();
-            if (callingGenseq !== undefined)
-                record.calling_genseq = callingGenseq;
+            if (callingGenseq !== undefined) {
+                record.calling_genseq = (0, storage_1.toCallingGenerationSeqNumber)(callingGenseq);
+            }
             if (calleeDialogId !== undefined)
                 record.calleeDialogId = calleeDialogId;
-            if (calleeCourse !== undefined)
-                record.calleeCourse = calleeCourse;
-            if (calleeGenseq !== undefined)
-                record.calleeGenseq = calleeGenseq;
+            if (calleeCourse !== undefined) {
+                record.calleeCourse = (0, storage_1.toCalleeCourseNumber)(calleeCourse);
+            }
+            if (calleeGenseq !== undefined) {
+                record.calleeGenseq = (0, storage_1.toCalleeGenerationSeqNumber)(calleeGenseq);
+            }
             if (sourceTag)
                 record.sourceTag = sourceTag;
             const { ts: _unusedTs, ...withoutTs } = record;
@@ -867,8 +981,9 @@ function parsePrimingScript(raw) {
     const titleRaw = frontmatter['title'];
     const title = typeof titleRaw === 'string' && titleRaw.trim() !== '' ? titleRaw.trim() : undefined;
     const applicableMemberIds = parseApplicableMemberIds(frontmatter);
+    const reminders = parseReminderSnapshots(frontmatter);
     const records = parseRecordsFromBody(body);
-    return { title, applicableMemberIds, records };
+    return { title, applicableMemberIds, reminders, records };
 }
 async function listMarkdownFilesRecursively(dirPath) {
     const files = [];
@@ -1198,6 +1313,7 @@ async function loadPrimingScriptByRef(scriptRefRaw, agentIdRaw) {
     }
     return {
         summary: loaded.summary,
+        reminders: (loaded.parsed.reminders ?? []).map((item, index) => materializeReminderSnapshot(item, `priming script '${scriptRef}' frontmatter.reminders[${String(index)}]`)),
         records: loaded.parsed.records,
     };
 }
@@ -1223,12 +1339,16 @@ function remapRecordGenseq(record, mapGenseq) {
         case 'teammate_call_result_record':
             return {
                 ...record,
-                calling_genseq: remapOptionalGenseq(record.calling_genseq),
+                calling_genseq: record.calling_genseq !== undefined
+                    ? (0, storage_1.toCallingGenerationSeqNumber)(remapOptionalGenseq(record.calling_genseq))
+                    : undefined,
             };
         case 'teammate_response_record':
             return {
                 ...record,
-                calling_genseq: remapOptionalGenseq(record.calling_genseq),
+                calling_genseq: record.calling_genseq !== undefined
+                    ? (0, storage_1.toCallingGenerationSeqNumber)(remapOptionalGenseq(record.calling_genseq))
+                    : undefined,
             };
         default: {
             const _exhaustive = record;
@@ -1422,16 +1542,26 @@ async function applyPrimingScriptsToDialog(args) {
         return { appliedScriptRefs: [], appendedMessageCount: 0 };
     }
     const allRecords = [];
+    const allReminders = [];
     let nextGenseq = getNextDialogGenseq(args.dialog);
     for (const scriptRef of normalizedRefs) {
         const loaded = await loadPrimingScriptByRef(scriptRef, agentId);
         const remapped = remapScriptRecordsForReplay(loaded.records, nextGenseq);
         nextGenseq = remapped.nextGenseq;
+        allReminders.push(...loaded.reminders);
         allRecords.push(...remapped.records);
     }
     if (allRecords.length === 0) {
         return { appliedScriptRefs: normalizedRefs, appendedMessageCount: 0 };
     }
+    if (allReminders.length > 0) {
+        args.dialog.reminders.splice(0, args.dialog.reminders.length, ...allReminders);
+        await persistence_1.DialogPersistence._saveReminderState(args.dialog.id, [...args.dialog.reminders], args.status);
+        await persistence_1.DialogPersistence.appendRemindersReconciledRecord(args.dialog.id, args.dialog.reminders, {
+            kind: 'root_anchor',
+            rootAnchor: (0, storage_1.toRootGenerationAnchor)({ rootCourse: 1, rootGenseq: 0 }),
+        }, args.status);
+    }
     for (const record of allRecords) {
         const withSourceTag = addPrimingSourceTag(record);
         const persisted = withTimestamp(withSourceTag, (0, time_1.formatUnifiedTimestamp)(new Date()));
@@ -1656,6 +1786,13 @@ function stripTimestampFromRecord(event) {
             const { ts: _unusedTs, ...withoutTs } = event;
             return withoutTs;
         }
+        case 'subdialog_created_record':
+        case 'reminders_reconciled_record':
+        case 'questions4human_reconciled_record':
+        case 'pending_subdialogs_reconciled_record':
+        case 'subdialog_registry_reconciled_record':
+        case 'subdialog_responses_reconciled_record':
+            throw new Error(`Record type ${event.type} is not supported in priming scripts`);
         default: {
             const _exhaustive = event;
             throw new Error(`Unhandled persisted record type: ${String(_exhaustive)}`);
@@ -1663,7 +1800,19 @@ function stripTimestampFromRecord(event) {
     }
 }
 function extractPrimingRecordsFromEvents(events) {
-    return events.map((event) => stripTimestampFromRecord(event));
+    return events.flatMap((event) => {
+        switch (event.type) {
+            case 'subdialog_created_record':
+            case 'reminders_reconciled_record':
+            case 'questions4human_reconciled_record':
+            case 'pending_subdialogs_reconciled_record':
+            case 'subdialog_registry_reconciled_record':
+            case 'subdialog_responses_reconciled_record':
+                return [];
+            default:
+                return [stripTimestampFromRecord(event)];
+        }
+    });
 }
 async function saveDialogCourseAsIndividualPrimingScript(args) {
     const normalizedSlug = normalizeSlug(args.slug);
@@ -1693,6 +1842,7 @@ async function saveDialogCourseAsIndividualPrimingScript(args) {
         throw new Error(`Priming script directory escapes individual scope: ${parentDir}`);
     }
     const now = (0, time_1.formatUnifiedTimestamp)(new Date());
+    const reminders = await persistence_1.DialogPersistence.loadReminderState(args.dialogId, args.status);
     const frontmatter = {
         kind: 'agent_priming_script',
         version: 3,
@@ -1706,6 +1856,9 @@ async function saveDialogCourseAsIndividualPrimingScript(args) {
             status: args.status,
         },
     };
+    if (reminders.length > 0) {
+        frontmatter['reminders'] = reminders.map((item) => reminderToSnapshot(item));
+    }
     const markdown = formatScriptMarkdown({ frontmatter, records });
     await promises_1.default.mkdir(parentDir, { recursive: true });
     const writeMode = args.overwrite === true ? 'w' : 'wx';

package/dist/server/api-routes.js

@@ -45,7 +45,9 @@ exports.handleApiRoute = handleApiRoute;
  */
 const promises_1 = __importDefault(require("fs/promises"));
 const path = __importStar(require("path"));
+const runtime_1 = require("../apps/runtime");
 const dialog_1 = require("../dialog");
+const dialog_fork_1 = require("../dialog-fork");
 const dialog_global_registry_1 = require("../dialog-global-registry");
 const dialog_run_state_1 = require("../dialog-run-state");
 const log_1 = require("../log");
@@ -1044,9 +1046,21 @@ async function handleApiRoute(req, res, pathname, context) {
         if (pathname === '/api/dialogs/move' && req.method === 'POST') {
             return await handleMoveDialogs(req, res, context);
         }
+        if (pathname.startsWith('/api/dialogs/') &&
+            pathname.endsWith('/fork') &&
+            req.method === 'POST') {
+            const parts = pathname.split('/');
+            const rawRoot = parts[3];
+            if (!rawRoot) {
+                respondJson(res, 400, { success: false, error: 'Missing root dialog id' });
+                return true;
+            }
+            return await handleForkDialog(req, res, context, rawRoot.replace(/%2F/g, '/'));
+        }
         // Delete a dialog (root dialogs only for now)
         if (pathname.startsWith('/api/dialogs/') &&
             !pathname.endsWith('/hierarchy') &&
+            !pathname.endsWith('/fork') &&
             req.method === 'DELETE') {
             const parts = pathname.split('/');
             const rawRoot = parts[3];
@@ -1606,6 +1620,7 @@ async function handleReadWorkspaceEntry(req, res) {
 }
 async function handleGetToolsRegistry(res) {
     try {
+        await (0, runtime_1.registerEnabledAppsToolProxies)({ rtwsRootAbs: process.cwd() });
         const snapshot = (0, registry_snapshot_1.createToolsRegistrySnapshot)();
         res.writeHead(200, {
             'Content-Type': 'application/json',
@@ -1975,6 +1990,73 @@ async function handleCreateDialog(req, res, context) {
         return true;
     }
 }
+async function handleForkDialog(req, res, context, rootIdRaw) {
+    try {
+        const body = await readRequestBody(req);
+        const parsed = JSON.parse(body);
+        if (!isRecord(parsed)) {
+            const payload = { success: false, error: 'Invalid JSON body' };
+            respondJson(res, 400, payload);
+            return true;
+        }
+        const courseRaw = parsed['course'];
+        const genseqRaw = parsed['genseq'];
+        const statusRaw = parsed['status'];
+        const rootId = rootIdRaw.trim();
+        const course = typeof courseRaw === 'number' && Number.isFinite(courseRaw) ? Math.floor(courseRaw) : 0;
+        const genseq = typeof genseqRaw === 'number' && Number.isFinite(genseqRaw) ? Math.floor(genseqRaw) : 0;
+        const status = parseDialogStatusKind(statusRaw) ?? 'running';
+        if (rootId === '') {
+            const payload = { success: false, error: 'rootId is required' };
+            respondJson(res, 400, payload);
+            return true;
+        }
+        if (course <= 0 || genseq <= 0) {
+            const payload = {
+                success: false,
+                error: 'course and genseq must be positive integers',
+            };
+            respondJson(res, 400, payload);
+            return true;
+        }
+        const result = await (0, dialog_fork_1.forkRootDialogTreeAtGeneration)({
+            sourceRootId: rootId,
+            sourceStatus: status,
+            course,
+            genseq,
+        });
+        const payload = {
+            success: true,
+            dialog: {
+                rootId: result.rootId,
+                selfId: result.selfId,
+                agentId: result.agentId,
+                agentName: result.agentId,
+                taskDocPath: result.taskDocPath,
+                status: 'running',
+            },
+            action: result.action,
+        };
+        respondJson(res, 201, payload);
+        broadcastDialogCreates(context.clients, {
+            type: 'dialogs_created',
+            scope: { kind: 'root', rootId: result.rootId },
+            status: 'running',
+            createdRootIds: [result.rootId],
+            timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        });
+        return true;
+    }
+    catch (error) {
+        log.error('Error forking dialog:', error);
+        const payload = {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to fork dialog',
+        };
+        respondJson(res, 500, payload);
+        return true;
+    }
+}
 async function handleMoveDialogs(req, res, context) {
     try {
         const body = await readRequestBody(req);

package/dist/server/setup-routes.js

@@ -371,11 +371,26 @@ function extractProminentEnumModelParams(modelParamOptions) {
             const defaultValue = typeof opt.default === 'string' && opt.values.includes(opt.default)
                 ? opt.default
                 : undefined;
+            const rawValueLabels = opt.value_labels;
+            let valueLabels;
+            if (rawValueLabels && typeof rawValueLabels === 'object' && !Array.isArray(rawValueLabels)) {
+                const next = {};
+                for (const [rawKey, rawLabel] of Object.entries(rawValueLabels)) {
+                    if (!opt.values.includes(rawKey))
+                        continue;
+                    if (typeof rawLabel !== 'string' || rawLabel.length === 0)
+                        continue;
+                    next[rawKey] = rawLabel;
+                }
+                if (Object.keys(next).length > 0)
+                    valueLabels = next;
+            }
             out.push({
                 namespace,
                 key,
                 description: opt.description,
                 values: opt.values,
+                ...(valueLabels ? { valueLabels } : {}),
                 ...(defaultValue ? { defaultValue } : {}),
             });
         }

package/dist/shared/types/storage.js

@@ -6,5 +6,82 @@
  * Uses modern TypeScript patterns for statically verifiable field access.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRootCourseNumber = toRootCourseNumber;
+exports.toRootGenerationSeqNumber = toRootGenerationSeqNumber;
+exports.toDialogCourseNumber = toDialogCourseNumber;
+exports.toCallingCourseNumber = toCallingCourseNumber;
+exports.toCallingGenerationSeqNumber = toCallingGenerationSeqNumber;
+exports.toAssignmentCourseNumber = toAssignmentCourseNumber;
+exports.toAssignmentGenerationSeqNumber = toAssignmentGenerationSeqNumber;
+exports.toCallerCourseNumber = toCallerCourseNumber;
+exports.toCalleeCourseNumber = toCalleeCourseNumber;
+exports.toCalleeGenerationSeqNumber = toCalleeGenerationSeqNumber;
+exports.toRootGenerationAnchor = toRootGenerationAnchor;
+function toRootCourseNumber(value) {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new Error(`Invalid root course number: ${String(value)}`);
+    }
+    return Math.floor(value);
+}
+function toRootGenerationSeqNumber(value) {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error(`Invalid root generation sequence number: ${String(value)}`);
+    }
+    return Math.floor(value);
+}
+function toDialogCourseNumber(value) {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new Error(`Invalid dialog course number: ${String(value)}`);
+    }
+    return Math.floor(value);
+}
+function toCallingCourseNumber(value) {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new Error(`Invalid calling course number: ${String(value)}`);
+    }
+    return Math.floor(value);
+}
+function toCallingGenerationSeqNumber(value) {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error(`Invalid calling generation sequence number: ${String(value)}`);
+    }
+    return Math.floor(value);
+}
+function toAssignmentCourseNumber(value) {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new Error(`Invalid assignment course number: ${String(value)}`);
+    }
+    return Math.floor(value);
+}
+function toAssignmentGenerationSeqNumber(value) {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error(`Invalid assignment generation sequence number: ${String(value)}`);
+    }
+    return Math.floor(value);
+}
+function toCallerCourseNumber(value) {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new Error(`Invalid caller course number: ${String(value)}`);
+    }
+    return Math.floor(value);
+}
+function toCalleeCourseNumber(value) {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new Error(`Invalid callee course number: ${String(value)}`);
+    }
+    return Math.floor(value);
+}
+function toCalleeGenerationSeqNumber(value) {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error(`Invalid callee generation sequence number: ${String(value)}`);
+    }
+    return Math.floor(value);
+}
+function toRootGenerationAnchor(args) {
+    return {
+        rootCourse: toRootCourseNumber(args.rootCourse),
+        rootGenseq: toRootGenerationSeqNumber(args.rootGenseq),
+    };
+}
 // always use switch statement for descriminated unions as modern typescript idiom,
 // no type guards and other helper functions should be defined and used

package/dist/static/assets/{_basePickBy-B2o4z1Hf.js → _basePickBy-B-A5XrWM.js}

@@ -1,5 +1,5 @@
-import { e as isSymbol, c as baseFlatten, g as baseIteratee, k as keys, h as baseFindIndex, j as baseEach, l as arrayMap, m as hasPath, n as castPath, t as toKey, o as baseGet } from "./_baseUniq-CLmcxjdl.js";
-import { aR as isObject, aA as baseRest, aS as isIterateeCall, aT as keysIn, aU as eq, aV as isArrayLike, aW as isArray, aX as identity, aY as isIndex, aZ as assignValue } from "./index-B-8J28g7.js";
+import { e as isSymbol, c as baseFlatten, g as baseIteratee, k as keys, h as baseFindIndex, j as baseEach, l as arrayMap, m as hasPath, n as castPath, t as toKey, o as baseGet } from "./_baseUniq-BANLb0cu.js";
+import { aR as isObject, aA as baseRest, aS as isIterateeCall, aT as keysIn, aU as eq, aV as isArrayLike, aW as isArray, aX as identity, aY as isIndex, aZ as assignValue } from "./index-DrTqAfFy.js";
 var reWhitespace = /\s/;
 function trimmedEndIndex(string) {
   var index = string.length;
@@ -193,4 +193,4 @@ export {
   map as m,
   toFinite as t
 };
-//# sourceMappingURL=_basePickBy-B2o4z1Hf.js.map
+//# sourceMappingURL=_basePickBy-B-A5XrWM.js.map