@kbediako/codex-orchestrator 0.1.37 → 0.2.0

package/dist/orchestrator/src/cli/run/manifestPersister.js

@@ -10,6 +10,7 @@ export class ManifestPersister {
     dirtyHeartbeat = false;
     timer = null;
     timerResolver = null;
+    scheduledWait = null;
     lastPersistAt = 0;
     pendingPersist = Promise.resolve();
     constructor(options) {
@@ -29,28 +30,22 @@ export class ManifestPersister {
             return this.pendingPersist;
         }
         if (force) {
-            this.clearTimer();
-            if (this.timerResolver) {
-                const resolver = this.timerResolver;
-                this.timerResolver = null;
-                resolver();
+            if (this.scheduledWait) {
+                this.scheduledWait.resolve();
                 return this.pendingPersist;
             }
             this.pendingPersist = this.pendingPersist.then(() => this.flushPersist());
             return this.pendingPersist;
         }
-        if (this.timer) {
+        if (this.scheduledWait) {
             return this.pendingPersist;
         }
-        const waitMs = Math.max(0, this.lastPersistAt + this.persistIntervalMs - this.now());
+        const scheduledWait = this.createScheduledWait();
         this.pendingPersist = this.pendingPersist
-            .then(() => new Promise((resolve) => {
-            this.timerResolver = resolve;
-            this.timer = setTimeout(() => {
-                this.clearTimer();
-                resolve();
-            }, waitMs);
-        }))
+            .then(() => {
+            scheduledWait.start();
+            return scheduledWait.promise;
+        })
             .then(() => this.flushPersist());
         return this.pendingPersist;
     }
@@ -63,6 +58,42 @@ export class ManifestPersister {
             this.timer = null;
         }
     }
+    createScheduledWait() {
+        let started = false;
+        let settled = false;
+        let resolvePromise;
+        const resolveWait = () => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            this.clearTimer();
+            if (this.timerResolver === resolveWait) {
+                this.timerResolver = null;
+            }
+            if (this.scheduledWait?.resolve === resolveWait) {
+                this.scheduledWait = null;
+            }
+            resolvePromise();
+        };
+        const scheduledWait = {
+            promise: new Promise((resolve) => {
+                resolvePromise = resolve;
+            }),
+            start: () => {
+                if (settled || started) {
+                    return;
+                }
+                started = true;
+                const waitMs = Math.max(0, this.lastPersistAt + this.persistIntervalMs - this.now());
+                this.timerResolver = resolveWait;
+                this.timer = setTimeout(resolveWait, waitMs);
+            },
+            resolve: resolveWait
+        };
+        this.scheduledWait = scheduledWait;
+        return scheduledWait;
+    }
     async flushPersist() {
         if (!this.dirtyManifest && !this.dirtyHeartbeat) {
             return;

package/dist/orchestrator/src/cli/run/runMemoryController.js

@@ -0,0 +1,216 @@
+import { buildRunSource0PromptLines, readRunSource0Descriptor } from './source0.js';
+const DEFAULT_MAX_PROMPT_PACK_EXPERIENCE_CHARS = 320;
+const RUN_MEMORY_ROLE_PROFILES = {
+    planner: {
+        role: 'planner',
+        include_source_0: true,
+        include_prompt_pack_experiences: true,
+        max_prompt_pack_experiences: 3,
+        max_prompt_pack_experience_chars: DEFAULT_MAX_PROMPT_PACK_EXPERIENCE_CHARS,
+        fallback_domains: ['planning', 'planner', 'implementation']
+    },
+    reviewer: {
+        role: 'reviewer',
+        include_source_0: true,
+        include_prompt_pack_experiences: false,
+        max_prompt_pack_experiences: 0,
+        max_prompt_pack_experience_chars: DEFAULT_MAX_PROMPT_PACK_EXPERIENCE_CHARS,
+        fallback_domains: []
+    },
+    executor: {
+        role: 'executor',
+        include_source_0: true,
+        include_prompt_pack_experiences: true,
+        max_prompt_pack_experiences: 3,
+        max_prompt_pack_experience_chars: DEFAULT_MAX_PROMPT_PACK_EXPERIENCE_CHARS,
+        fallback_domains: ['implementation']
+    },
+    delegate: {
+        role: 'delegate',
+        include_source_0: true,
+        include_prompt_pack_experiences: false,
+        max_prompt_pack_experiences: 0,
+        max_prompt_pack_experience_chars: DEFAULT_MAX_PROMPT_PACK_EXPERIENCE_CHARS,
+        fallback_domains: []
+    }
+};
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function readPromptPackDomain(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function normalizePromptSnippet(value) {
+    return value.replace(/\s+/gu, ' ').trim();
+}
+function truncatePromptSnippet(value, maxChars) {
+    if (!Number.isFinite(maxChars) || maxChars <= 0 || value.length <= maxChars) {
+        return value;
+    }
+    const safeMaxChars = Math.max(1, Math.trunc(maxChars));
+    if (safeMaxChars <= 3) {
+        return value.slice(0, safeMaxChars);
+    }
+    return `${value.slice(0, safeMaxChars - 3).trimEnd()}...`;
+}
+function readPromptPackSources(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .filter((entry) => typeof entry === 'string')
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+}
+function readPromptPackCandidates(manifest) {
+    if (!isRecord(manifest) || !Array.isArray(manifest.prompt_packs)) {
+        return [];
+    }
+    return manifest.prompt_packs.flatMap((entry) => {
+        if (!isRecord(entry)) {
+            return [];
+        }
+        const domain = readPromptPackDomain(entry.domain);
+        const id = typeof entry.id === 'string' ? entry.id.trim() : '';
+        const stamp = typeof entry.stamp === 'string' ? entry.stamp.trim() : '';
+        const experiences = Array.isArray(entry.experiences)
+            ? entry.experiences
+                .map((item, index) => ({
+                index,
+                value: typeof item === 'string' ? normalizePromptSnippet(item) : ''
+            }))
+                .filter((item) => item.value.length > 0)
+            : [];
+        if (!domain || !id || !stamp || experiences.length === 0) {
+            return [];
+        }
+        return [
+            {
+                packRef: {
+                    id,
+                    domain,
+                    stamp,
+                    sources: readPromptPackSources(entry.sources)
+                },
+                experiences,
+                domain_lower: domain.toLowerCase()
+            }
+        ];
+    });
+}
+function buildHintHaystack(hints) {
+    return (hints ?? [])
+        .map((hint) => normalizePromptSnippet(hint))
+        .filter((hint) => hint.length > 0)
+        .join(' ')
+        .toLowerCase();
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+}
+function hasHintDomain(haystack, domain) {
+    return new RegExp(`(^|\\W)${escapeRegExp(domain)}($|\\W)`, 'u').test(haystack);
+}
+function selectPromptPackCandidate(params) {
+    if (!params.profile.include_prompt_pack_experiences || params.candidates.length === 0) {
+        return null;
+    }
+    for (const packId of params.preferred_prompt_pack_ids ?? []) {
+        const normalizedPackId = packId.trim();
+        if (normalizedPackId.length === 0) {
+            continue;
+        }
+        const explicitMatch = params.candidates.find((candidate) => candidate.packRef.id === normalizedPackId);
+        if (explicitMatch) {
+            return { candidate: explicitMatch, reason: 'explicit' };
+        }
+    }
+    const haystack = buildHintHaystack(params.hints);
+    if (haystack.length > 0) {
+        const directMatch = params.candidates.find((candidate) => candidate.domain_lower !== 'implementation' &&
+            hasHintDomain(haystack, candidate.domain_lower));
+        if (directMatch) {
+            return { candidate: directMatch, reason: 'hint' };
+        }
+        const broadMatch = params.candidates.find((candidate) => hasHintDomain(haystack, candidate.domain_lower));
+        if (broadMatch) {
+            return { candidate: broadMatch, reason: 'hint' };
+        }
+    }
+    for (const domain of params.profile.fallback_domains) {
+        const fallback = params.candidates.find((candidate) => candidate.domain_lower === domain);
+        if (fallback) {
+            return { candidate: fallback, reason: 'fallback' };
+        }
+    }
+    return params.candidates[0] ? { candidate: params.candidates[0], reason: 'first_available' } : null;
+}
+export function getRunMemoryRoleProfile(role) {
+    const profile = RUN_MEMORY_ROLE_PROFILES[role];
+    return {
+        ...profile,
+        fallback_domains: [...profile.fallback_domains]
+    };
+}
+export function selectRunMemoryForRole(params) {
+    const profile = getRunMemoryRoleProfile(params.role);
+    const refs = [];
+    if (profile.include_source_0 && params.include_source_0 !== false) {
+        const descriptor = readRunSource0Descriptor(params.manifest);
+        if (descriptor) {
+            refs.push({ kind: 'source_0', descriptor });
+        }
+    }
+    const selectedPromptPack = selectPromptPackCandidate({
+        candidates: readPromptPackCandidates(params.manifest),
+        hints: params.hints ?? [],
+        profile,
+        preferred_prompt_pack_ids: params.preferred_prompt_pack_ids
+    });
+    if (selectedPromptPack) {
+        const experienceLimit = Math.max(0, profile.max_prompt_pack_experiences);
+        refs.push(...selectedPromptPack.candidate.experiences
+            .slice(0, experienceLimit)
+            .map((experience) => ({
+            kind: 'prompt_pack_experience',
+            pack: selectedPromptPack.candidate.packRef,
+            experience_index: experience.index,
+            experience: truncatePromptSnippet(experience.value, profile.max_prompt_pack_experience_chars),
+            selection_reason: selectedPromptPack.reason
+        })));
+    }
+    return {
+        role: params.role,
+        profile,
+        refs
+    };
+}
+export function buildRunMemoryPromptLines(selection) {
+    const lines = [];
+    const source0Ref = selection.refs.find((ref) => ref.kind === 'source_0');
+    if (source0Ref) {
+        lines.push(...buildRunSource0PromptLines(source0Ref.descriptor));
+    }
+    const promptPackRefs = selection.refs.filter((ref) => ref.kind === 'prompt_pack_experience');
+    if (promptPackRefs.length === 0) {
+        return lines;
+    }
+    const [firstRef] = promptPackRefs;
+    if (lines.length > 0) {
+        lines.push('');
+    }
+    lines.push('Relevant prior experiences (hints, not strict instructions):', `- Retrieval profile: ${selection.role}`, `- Domain: ${firstRef.pack.domain}`, `- Pack id: ${firstRef.pack.id}`, `- Pack stamp: ${firstRef.pack.stamp}`, `- Selection reason: ${firstRef.selection_reason}`);
+    if (firstRef.pack.sources.length > 0) {
+        lines.push(`- Pack sources: ${firstRef.pack.sources.join(', ')}`);
+    }
+    lines.push(...promptPackRefs.map((ref, index) => `${index + 1}. ${ref.experience}`));
+    return lines;
+}
+export const __test__ = {
+    readPromptPackCandidates,
+    selectPromptPackCandidate
+};