fraim 2.0.171 → 2.0.174

package/dist/src/ai-hub/hosts.js

@@ -275,7 +275,223 @@ function extractSignalFromArgs(args) {
     const jobName = typeof args.jobName === 'string' ? args.jobName : undefined;
     const jobId = typeof args.jobId === 'string' ? args.jobId : undefined;
     const reviewHandoff = extractReviewHandoffFromArgs(args);
-    return { phaseId, phaseStatus, findingsText, discriminant, jobName, jobId, ...(reviewHandoff ? { reviewHandoff } : {}) };
+    const delegationLedger = extractDelegationLedgerFromArgs(args);
+    return {
+        phaseId,
+        phaseStatus,
+        findingsText,
+        discriminant,
+        jobName,
+        jobId,
+        ...(reviewHandoff ? { reviewHandoff } : {}),
+        ...(delegationLedger ? { delegationLedger } : {}),
+    };
+}
+function extractDelegationLedgerFromArgs(args) {
+    const direct = readDelegationLedgerCandidate(args.delegationGraph) ||
+        readDelegationLedgerCandidate(args.delegationLedger) ||
+        readDelegationLedgerCandidate(args.delegation_ledger);
+    if (direct)
+        return direct;
+    const evidence = args.evidence;
+    if (!evidence || typeof evidence !== 'object' || Array.isArray(evidence))
+        return null;
+    const e = evidence;
+    const nested = readDelegationLedgerCandidate(e.delegationGraph) ||
+        readDelegationLedgerCandidate(e.delegationLedger) ||
+        readDelegationLedgerCandidate(e.delegation_ledger);
+    if (nested)
+        return nested;
+    const objective = stringValue(e.goal) || stringValue(e.objective) || stringValue(e.parentObjective) || stringValue(args.jobName) || 'Delegated manager objective';
+    return ledgerFromExecutionPlan(e.execution_plan, objective) || ledgerFromApprovedPlan(e.approved_plan, objective);
+}
+function readDelegationLedgerCandidate(value) {
+    let candidate = value;
+    if (typeof candidate === 'string') {
+        try {
+            candidate = JSON.parse(candidate);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate))
+        return null;
+    const obj = candidate;
+    const rawJobs = Array.isArray(obj.jobs) ? obj.jobs : Array.isArray(obj.tasks) ? obj.tasks : [];
+    if (obj.delegationRequired !== true || !rawJobs.length)
+        return null;
+    const objective = stringValue(obj.objective) || 'Delegated manager objective';
+    const tasks = rawJobs.map((task, index) => normalizeDelegationTaskCandidate(task, index)).filter(Boolean);
+    if (!tasks.length)
+        return null;
+    return {
+        delegationRequired: true,
+        objective,
+        orchestratorPersonaKey: stringValue(obj.orchestratorPersonaKey) || 'mandy',
+        latestSummary: stringValue(obj.latestSummary) || undefined,
+        tasks,
+    };
+}
+function ledgerFromExecutionPlan(value, objective) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const plan = value;
+    const tasks = [];
+    for (const [groupKey, groupValue] of Object.entries(plan)) {
+        if (!Array.isArray(groupValue))
+            continue;
+        for (const rawTask of groupValue) {
+            const task = normalizeExecutionPlanTask(rawTask, tasks.length, groupKey);
+            if (task)
+                tasks.push(task);
+        }
+    }
+    if (!tasks.length)
+        return null;
+    return {
+        delegationRequired: true,
+        objective,
+        orchestratorPersonaKey: 'mandy',
+        latestSummary: stringValue(plan.dependencies) || undefined,
+        tasks,
+    };
+}
+function ledgerFromApprovedPlan(value, objective) {
+    if (!Array.isArray(value))
+        return null;
+    const tasks = value.map((entry, index) => normalizeApprovedPlanEntry(entry, index)).filter(Boolean);
+    if (!tasks.length)
+        return null;
+    return {
+        delegationRequired: true,
+        objective,
+        orchestratorPersonaKey: 'mandy',
+        tasks,
+    };
+}
+function normalizeExecutionPlanTask(value, index, groupKey) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const obj = value;
+    const personaKey = normalizePersonaKey(stringValue(obj.persona) || stringValue(obj.personaKey));
+    const jobId = normalizeJobId(stringValue(obj.job) || stringValue(obj.jobId));
+    const scope = stringValue(obj.scope) || stringValue(obj.instructions) || stringValue(obj.summary);
+    const title = stringValue(obj.title) || humanizeJobId(jobId || `workstream-${index + 1}`);
+    if (!jobId)
+        return null;
+    return {
+        taskId: stringValue(obj.jobKey) || stringValue(obj.taskId) || uniqueTaskId(`${personaKey || 'job'}-${jobId}`, index),
+        title,
+        status: 'planned',
+        personaKey,
+        jobId,
+        dependsOn: dependenciesForGroup(groupKey),
+        reviewJobId: normalizeJobId(stringValue(obj.reviewJobId) || stringValue(obj.review?.jobId || '')),
+        reviewType: stringValue(obj.reviewType) || stringValue(obj.review?.type || '') || null,
+        instructions: scope || `Complete ${title} and return a concise deliverable to Mandy for review.`,
+    };
+}
+function normalizeApprovedPlanEntry(value, index) {
+    const text = stringValue(value);
+    if (!text)
+        return null;
+    const match = text.match(/^\s*(?:(\w+)\s*[/]\s*)?([a-z0-9][a-z0-9-]*)\s*:?\s*(.*)$/i);
+    if (!match)
+        return null;
+    const personaKey = normalizePersonaKey(match[1] || '');
+    const jobId = normalizeJobId(match[2]);
+    const scope = match[3]?.trim() || '';
+    if (!jobId)
+        return null;
+    const title = scope ? titleFromScope(scope, jobId) : humanizeJobId(jobId);
+    return {
+        taskId: uniqueTaskId(`${personaKey || 'job'}-${jobId}`, index),
+        title,
+        status: 'planned',
+        personaKey,
+        jobId,
+        dependsOn: [],
+        instructions: scope || `Complete ${title} and return a concise deliverable to Mandy for review.`,
+    };
+}
+function normalizeDelegationTaskCandidate(value, index) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const obj = value;
+    const title = stringValue(obj.title) || humanizeJobId(stringValue(obj.jobId) || stringValue(obj.job) || `workstream-${index + 1}`);
+    const personaKey = normalizePersonaKey(stringValue(obj.personaKey) || stringValue(obj.persona));
+    const jobId = normalizeJobId(stringValue(obj.jobId) || stringValue(obj.job));
+    if (!title || !jobId)
+        return null;
+    const review = obj.review && typeof obj.review === 'object' && !Array.isArray(obj.review)
+        ? obj.review
+        : {};
+    return {
+        taskId: stringValue(obj.jobKey) || stringValue(obj.taskId) || uniqueTaskId(`${personaKey || 'job'}-${jobId}`, index),
+        title,
+        status: 'planned',
+        personaKey,
+        jobId,
+        reviewJobId: normalizeJobId(stringValue(obj.reviewJobId) || stringValue(review.jobId)),
+        reviewType: stringValue(obj.reviewType) || stringValue(review.type) || null,
+        instructions: stringValue(obj.instructions) || stringValue(obj.scope) || undefined,
+        latestSummary: stringValue(obj.latestSummary) || undefined,
+        dependsOn: Array.isArray(obj.dependsOn) ? obj.dependsOn.map(stringValue).filter(Boolean) : [],
+    };
+}
+function stringValue(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function normalizePersonaKey(value) {
+    const cleaned = value.trim().replace(/^\[|\]$/g, '').toLowerCase();
+    if (!cleaned)
+        return null;
+    const aliases = {
+        beza: 'beza',
+        pam: 'pam',
+        gautam: 'gautam',
+        swen: 'swen',
+        qasm: 'qasm',
+        huxley: 'huxley',
+        recardo: 'recardo',
+        hari: 'hari',
+        mandy: 'mandy',
+    };
+    return aliases[cleaned] || cleaned.replace(/[^a-z0-9-]/g, '');
+}
+function normalizeJobId(value) {
+    const cleaned = value.trim().toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/^-+|-+$/g, '');
+    return cleaned || null;
+}
+function uniqueTaskId(base, index) {
+    const cleaned = normalizeJobId(base) || `task-${index + 1}`;
+    return `${cleaned}-${index + 1}`;
+}
+function humanizeJobId(value) {
+    return value
+        .split(/[-_\s]+/)
+        .filter(Boolean)
+        .map((part) => `${part[0]?.toUpperCase() || ''}${part.slice(1)}`)
+        .join(' ') || 'Delegated workstream';
+}
+function titleFromScope(scope, jobId) {
+    const trimmed = scope.trim();
+    if (!trimmed)
+        return humanizeJobId(jobId);
+    const sentence = trimmed.split(/[.;]/)[0]?.trim();
+    if (!sentence)
+        return humanizeJobId(jobId);
+    return sentence.length <= 80 ? sentence : sentence.slice(0, 77).trimEnd() + '...';
+}
+function dependenciesForGroup(groupKey) {
+    const match = groupKey.match(/group[_-\s]*(\d+)/i);
+    if (!match)
+        return [];
+    const group = Number(match[1]);
+    if (!Number.isFinite(group) || group <= 1)
+        return [];
+    return [`group-${group - 1}`];
 }
 function extractReviewHandoffFromArgs(args) {
     const direct = readReviewHandoffCandidate(args.reviewHandoff);
@@ -595,7 +811,7 @@ function buildStartPlan(hostId, message, sessionId) {
             // Gemini CLI creates the durable session id itself. Hub captures
             // that real id from Gemini's chat log after start; pre-seeded UUIDs
             // are not reliably accepted by `gemini --resume`.
-            args: ['--yolo', '--skip-trust', '-p', ' ', ...browser.args],
+            args: ['--yolo', '--skip-trust', '-p', 'stdin', ...browser.args],
             stdin: prompt,
             env: browser.env,
         };
@@ -640,7 +856,7 @@ function buildContinuePlan(hostId, sessionId, message) {
         const browser = sharedBrowserHostConfig('gemini');
         return {
             command: executableName('gemini'),
-            args: ['--resume', sessionId, '--yolo', '--skip-trust', '-p', ' ', ...browser.args],
+            args: ['--resume', sessionId, '--yolo', '--skip-trust', '-p', 'stdin', ...browser.args],
             stdin: prompt,
             env: browser.env,
         };
@@ -703,7 +919,7 @@ function buildDirectStartPlan(hostId, message, sessionId) {
         ensureGeminiApiKey();
         return {
             command: executableName('gemini'),
-            args: ['--yolo', '--skip-trust', '-p', ' '],
+            args: ['--yolo', '--skip-trust', '-p', 'stdin'],
             stdin: DIRECT_PREAMBLE + message,
         };
     }
@@ -741,7 +957,7 @@ function buildDirectContinuePlan(hostId, sessionId, message) {
         ensureGeminiApiKey();
         return {
             command: executableName('gemini'),
-            args: ['--resume', sessionId, '--yolo', '--skip-trust', '-p', ' '],
+            args: ['--resume', sessionId, '--yolo', '--skip-trust', '-p', 'stdin'],
             stdin: DIRECT_PREAMBLE + message,
         };
     }
@@ -818,7 +1034,8 @@ function parseHostLine(hostId, line) {
             if (isGeminiCliNotice(trimmed)) {
                 return withSignal({ raw: trimmed });
             }
-            return withSignal({ message: trimmed, raw: trimmed });
+            const message = scrubGeminiAssistantLine(trimmed);
+            return withSignal(message ? { message, raw: trimmed } : { raw: trimmed });
         }
     }
     // GitHub Copilot CLI output: JSON stream where each event carries a `type`
@@ -873,6 +1090,10 @@ function isGeminiCliNotice(line) {
     return line === 'YOLO mode is enabled. All tool calls will be automatically approved.' ||
         line === 'Ripgrep is not available. Falling back to GrepTool.';
 }
+function scrubGeminiAssistantLine(line) {
+    const scrubbed = line.replace(/\[Thought:\s*true\]\s*/gi, '').trim();
+    return scrubbed.length > 0 ? scrubbed : null;
+}
 function wireHostProcess(hostId, child, handlers) {
     const wire = (buffer, channel) => {
         let pending = '';