fraim-framework 2.0.153 → 2.0.159

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

@@ -10,6 +10,9 @@ exports.parseAgentIdentitySignal = parseAgentIdentitySignal;
 exports.detectEmployees = detectEmployees;
 exports.buildStartPlan = buildStartPlan;
 exports.buildContinuePlan = buildContinuePlan;
+exports.supportsDirectPath = supportsDirectPath;
+exports.buildDirectStartPlan = buildDirectStartPlan;
+exports.buildDirectContinuePlan = buildDirectContinuePlan;
 exports.parseHostLine = parseHostLine;
 const crypto_1 = require("crypto");
 const child_process_1 = require("child_process");
@@ -252,6 +255,7 @@ function detectEmployees() {
             label: EMPLOYEE_LABELS[id],
             available,
             detail: available ? 'Installed and ready on this machine.' : 'CLI not detected on this machine.',
+            supportsRaw: supportsDirectPath(id),
         };
     });
 }
@@ -370,6 +374,93 @@ function buildContinuePlan(hostId, sessionId, message) {
         stdin: transformHeadlessFraimMessage(message, 'continue'),
     };
 }
+// Issue #442: all agents support a direct-path invocation (no FRAIM, no
+// transformHeadlessFraimMessage). Claude uses --strict-mcp-config for isolation;
+// Codex and Gemini simply omit the FRAIM preamble and run raw.
+function supportsDirectPath(_hostId) {
+    return true;
+}
+// Empty MCP config for Direct runs. Always overwritten on each use so a
+// pre-existing file in tmp cannot inject MCP server definitions (SEC-A04).
+const EMPTY_MCP_CONFIG_PATH = path_1.default.join(os_1.default.tmpdir(), 'fraim-direct-empty-mcp.json');
+function ensureEmptyMcpConfig() {
+    fs_1.default.writeFileSync(EMPTY_MCP_CONFIG_PATH, '{"mcpServers":{}}', { encoding: 'utf8', mode: 0o600 });
+    return EMPTY_MCP_CONFIG_PATH;
+}
+// Issue #442: --append-system-prompt overrides CLAUDE.md instructions at the
+// system-prompt level (CLAUDE.md is prepended to the system prompt; appending
+// after it gives the Direct-mode directive precedence). --strict-mcp-config
+// blocks MCP servers (FRAIM excluded). Both are required:
+// --append-system-prompt alone doesn't block MCP tools; --strict-mcp-config
+// alone doesn't suppress CLAUDE.md's "scan job stubs" instruction.
+const DIRECT_SYSTEM_PROMPT_OVERRIDE = 'DO NOT USE FRAIM FOR THIS SESSION. ' +
+    'You are operating in Direct mode for an A/B comparison — no FRAIM, no phases, no seekMentoring, ' +
+    'no job stubs, no structured workflow. Ignore all CLAUDE.md instructions to scan fraim/ or call get_fraim_job. ' +
+    'Answer the user directly and conversationally.';
+const DIRECT_PREAMBLE = 'DO NOT USE FRAIM FOR THIS SESSION. No phases, no seekMentoring, no structured workflow.\n\n';
+// Issue #442: builds a CLI plan for the Direct (B) side of an A/B run.
+// All agents supported: Codex and Gemini run raw (no FRAIM preamble);
+// Claude uses --strict-mcp-config + --append-system-prompt for full isolation.
+function buildDirectStartPlan(hostId, message) {
+    if (hostId === 'codex') {
+        return {
+            command: executableName('codex'),
+            args: ['exec', '--json', '--skip-git-repo-check', '--dangerously-bypass-approvals-and-sandbox'],
+            stdin: DIRECT_PREAMBLE + message,
+        };
+    }
+    if (hostId === 'gemini') {
+        ensureGeminiApiKey();
+        return {
+            command: executableName('gemini'),
+            args: ['--yolo', '--skip-trust'],
+            stdin: DIRECT_PREAMBLE + message,
+        };
+    }
+    return {
+        command: executableName('claude'),
+        args: [
+            '-p',
+            '--verbose',
+            '--output-format', 'stream-json',
+            '--dangerously-skip-permissions',
+            '--strict-mcp-config',
+            '--mcp-config', ensureEmptyMcpConfig(),
+            '--append-system-prompt', DIRECT_SYSTEM_PROMPT_OVERRIDE,
+        ],
+        stdin: DIRECT_PREAMBLE + message,
+    };
+}
+function buildDirectContinuePlan(hostId, sessionId, message) {
+    if (hostId === 'codex') {
+        return {
+            command: executableName('codex'),
+            args: ['exec', 'resume', '--json', '--skip-git-repo-check', '--dangerously-bypass-approvals-and-sandbox', sessionId],
+            stdin: DIRECT_PREAMBLE + message,
+        };
+    }
+    if (hostId === 'gemini') {
+        ensureGeminiApiKey();
+        return {
+            command: executableName('gemini'),
+            args: ['--yolo', '--skip-trust'],
+            stdin: DIRECT_PREAMBLE + message,
+        };
+    }
+    return {
+        command: executableName('claude'),
+        args: [
+            '-p',
+            '--verbose',
+            '--output-format', 'stream-json',
+            '--dangerously-skip-permissions',
+            '--resume', sessionId,
+            '--strict-mcp-config',
+            '--mcp-config', ensureEmptyMcpConfig(),
+        ],
+        stdin: message,
+    };
+}
 function parseHostLine(hostId, line) {
     const trimmed = line.trim();
     if (!trimmed)
@@ -395,6 +486,11 @@ function parseHostLine(hostId, line) {
             if (parsed.type === 'item.completed' && parsed.item?.type === 'agent_message' && parsed.item.text) {
                 return withSignal({ message: parsed.item.text, raw: trimmed });
             }
+            // turn_context carries the active model — capture it as agentIdentity so
+            // direct runs (which never call fraim_connect) can still compute cost.
+            if (parsed.type === 'turn_context' && typeof parsed.payload?.model === 'string') {
+                return withSignal({ raw: trimmed, agentIdentity: { agentName: 'codex', agentModel: parsed.payload.model } });
+            }
             return withSignal({ raw: trimmed });
         }
         catch {
@@ -424,8 +520,10 @@ function parseHostLine(hostId, line) {
                 return withSignal({ message: text, sessionId: parsed.session_id, raw: trimmed });
             }
         }
-        if (parsed.type === 'result' && parsed.result) {
-            return withSignal({ message: parsed.result, sessionId: parsed.session_id, raw: trimmed });
+        if (parsed.type === 'result') {
+            // Don't emit message — the 'assistant' event already captured the turn text.
+            // result carries usage data (parsed by parseUsageSignal above via withSignal).
+            return withSignal({ sessionId: parsed.session_id, raw: trimmed });
         }
         return withSignal({ raw: trimmed });
     }
@@ -484,14 +582,20 @@ class CliHostRuntime {
     continueRun(hostId, projectPath, sessionId, message, handlers) {
         return spawnHostProcess(hostId, buildContinuePlan(hostId, sessionId, message), projectPath, handlers);
     }
+    startDirectRun(hostId, message, projectPath, handlers) {
+        return spawnHostProcess(hostId, buildDirectStartPlan(hostId, message), projectPath, handlers);
+    }
+    continueDirectRun(hostId, sessionId, message, projectPath, handlers) {
+        return spawnHostProcess(hostId, buildDirectContinuePlan(hostId, sessionId, message), projectPath, handlers);
+    }
 }
 exports.CliHostRuntime = CliHostRuntime;
 class FakeHostRuntime {
     constructor() {
         this.employees = [
-            { id: 'codex', label: 'Codex', available: true, detail: 'Test double employee.' },
-            { id: 'claude', label: 'Claude Code', available: true, detail: 'Test double employee.' },
-            { id: 'gemini', label: 'Gemini CLI', available: true, detail: 'Test double employee.' },
+            { id: 'codex', label: 'Codex', available: true, detail: 'Test double employee.', supportsRaw: true },
+            { id: 'claude', label: 'Claude Code', available: true, detail: 'Test double employee.', supportsRaw: true },
+            { id: 'gemini', label: 'Gemini CLI', available: true, detail: 'Test double employee.', supportsRaw: true },
         ];
     }
     detectEmployees() {
@@ -503,6 +607,12 @@ class FakeHostRuntime {
     continueRun(hostId, _projectPath, sessionId, message, handlers) {
         return this.fakeProcess(hostId, this.fakeEmployeeReply('continue', message), handlers);
     }
+    startDirectRun(hostId, _message, _projectPath, handlers) {
+        return this.fakeProcess(hostId, 'Understood. Working directly on that now.', handlers);
+    }
+    continueDirectRun(hostId, _sessionId, _message, _projectPath, handlers) {
+        return this.fakeProcess(hostId, 'Got it. Continuing directly.', handlers);
+    }
     fakeProcess(_hostId, text, handlers) {
         handlers.onEvent({ sessionId: (0, crypto_1.randomUUID)() }, 'system');
         handlers.onEvent({ message: text }, 'stdout');
@@ -563,9 +673,9 @@ exports.FakeHostRuntime = FakeHostRuntime;
 class ScriptedHostRuntime {
     constructor() {
         this.employees = [
-            { id: 'codex', label: 'Codex', available: true, detail: 'Scripted test double.' },
-            { id: 'claude', label: 'Claude Code', available: true, detail: 'Scripted test double.' },
-            { id: 'gemini', label: 'Gemini CLI', available: true, detail: 'Scripted test double.' },
+            { id: 'codex', label: 'Codex', available: true, detail: 'Scripted test double.', supportsRaw: true },
+            { id: 'claude', label: 'Claude Code', available: true, detail: 'Scripted test double.', supportsRaw: true },
+            { id: 'gemini', label: 'Gemini CLI', available: true, detail: 'Scripted test double.', supportsRaw: true },
         ];
         // Track each active run so the test can emit signals at it. Key is the
         // sessionId we hand back on startRun; mapping sessionId → handlers
@@ -589,6 +699,16 @@ class ScriptedHostRuntime {
         handlers.onEvent({ sessionId, raw: 'scripted-session-resume' }, 'system');
         return this.spawnDouble();
     }
+    startDirectRun(_hostId, _message, _projectPath, handlers) {
+        const sessionId = (0, crypto_1.randomUUID)();
+        handlers.onEvent({ sessionId, raw: 'scripted-direct-session-start' }, 'system');
+        return this.spawnDouble();
+    }
+    continueDirectRun(_hostId, sessionId, _message, _projectPath, handlers) {
+        this.handlersBySession.set(sessionId, handlers);
+        handlers.onEvent({ sessionId, raw: 'scripted-direct-session-resume' }, 'system');
+        return this.spawnDouble();
+    }
     // Test API — fire a seekMentoring tool-use event for the most recent
     // active run. The phaseId is the raw FSM phase id (e.g.,
     // 'implement-validate'); the parser will turn it into a friendly
@@ -670,6 +790,13 @@ class ScriptedHostRuntime {
             agentIdentity: { agentName, agentModel },
         }, 'stdout');
     }
+    // Test API — emit a message from the employee (appears in the thread as an employee bubble).
+    emitEmployeeMessage(runId, text) {
+        const target = this.resolveSession(runId);
+        if (!target)
+            return;
+        target.handlers.onEvent({ sessionId: target.sessionId, message: text, raw: `scripted-employee:${text.slice(0, 40)}` }, 'stdout');
+    }
     // Reset between tests (called from beforeEach).
     reset() {
         this.handlersBySession.clear();

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

@@ -421,10 +421,91 @@ class AiHubServer {
             this.ownsDbService = this.dbService !== undefined;
         }
         this.app.use(express_1.default.json());
+        // CORS for browser extension and Office add-in task panes calling localhost Hub
+        this.app.use((_req, res, next) => {
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+            if (_req.method === 'OPTIONS') {
+                res.sendStatus(204);
+                return;
+            }
+            next();
+        });
         this.app.use('/ai-hub', express_1.default.static(resolveAiHubPublicDir()));
         this.app.get('/health', (_req, res) => {
             res.json({ status: 'ok', service: 'fraim-ai-hub' });
         });
+        // Extended health endpoint for trigger surfaces (browser extension, Office add-ins, tray)
+        this.app.get('/api/health', (_req, res) => {
+            res.json({ status: 'ok', service: 'fraim-ai-hub' });
+        });
+        // Trigger endpoint for external surfaces (browser extension, Office add-ins, tray).
+        // Starts a real Hub run and returns the runId for polling via GET /api/ai-hub/runs/:runId.
+        this.app.post('/api/trigger', (req, res) => {
+            const { employeeId, jobName, context, projectPath } = req.body;
+            if (!employeeId || !jobName) {
+                res.status(400).json({ error: 'employeeId and jobName are required' });
+                return;
+            }
+            const contextSummary = [
+                context?.sourceApp ? `Source: ${context.sourceApp}` : '',
+                context?.fileName ? `File: ${context.fileName}` : '',
+                context?.text ? `Context:\n${context.text.slice(0, 500)}` : '',
+            ].filter(Boolean).join('\n');
+            const message = `/fraim ${jobName}\n\n${contextSummary}`.trim();
+            const hostId = 'claude';
+            const resolvedPath = projectPath || this.projectPath;
+            try {
+                const employee = this.hostRuntime.detectEmployees().find((e) => e.id === hostId);
+                if (!employee?.available) {
+                    res.status(503).json({ error: `${hostId} is not available on this machine` });
+                    return;
+                }
+                const now = new Date().toISOString();
+                const run = {
+                    id: (0, crypto_1.randomUUID)(),
+                    jobId: jobName,
+                    hostId,
+                    projectPath: resolvedPath,
+                    status: 'running',
+                    createdAt: now,
+                    updatedAt: now,
+                    messages: [(0, hosts_1.createHubMessage)('manager', message)],
+                    events: [(0, hosts_1.createHubEvent)('system', `Starting ${hostId} via ${context?.sourceApp || 'external-surface'} in ${resolvedPath}`)],
+                    currentPhase: null,
+                    phaseHistory: [],
+                    totals: emptyTotals(),
+                    lastStatusChangeAt: now,
+                    personaKey: getProtectedPersonaForHubJob(jobName),
+                };
+                const child = this.hostRuntime.startRun(hostId, resolvedPath, message, {
+                    onEvent: (event, channel) => {
+                        this.runRegistry.update(run.id, (current) => {
+                            if (event.sessionId)
+                                current.sessionId = event.sessionId;
+                            if (event.message)
+                                current.messages.push((0, hosts_1.createHubMessage)('employee', event.message));
+                            if (event.raw)
+                                current.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
+                        });
+                    },
+                    onExit: (exitCode) => {
+                        this.runRegistry.update(run.id, (current) => {
+                            current.exitCode = exitCode;
+                            current.status = exitCode === 0 ? 'completed' : 'failed';
+                            current.events.push((0, hosts_1.createHubEvent)('system', `Run exited with code ${exitCode ?? 'unknown'}.`));
+                        });
+                        this.runRegistry.dispose(run.id);
+                    },
+                });
+                this.runRegistry.create(run, child);
+                res.json({ runId: run.id, status: 'started', employee: employeeId, job: jobName });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
         this.registerRoutes();
     }
     getApp() {
@@ -648,6 +729,7 @@ class AiHubServer {
                 const hostId = req.body.hostId;
                 const jobId = req.body.jobId;
                 const message = (req.body.message || '').trim();
+                const compareMode = req.body.compareMode;
                 if (hostId !== 'codex' && hostId !== 'claude' && hostId !== 'gemini') {
                     throw new Error('Choose an available employee before starting a job.');
                 }
@@ -682,8 +764,43 @@ class AiHubServer {
                     // pre-seed one so the Send button is enabled and the continue
                     // endpoint can proceed. continueRun for Gemini ignores it.
                     ...(hostId === 'gemini' ? { sessionId: (0, crypto_1.randomUUID)() } : {}),
+                    // Issue #442: mark this as the FRAIM side of an A/B pair when applicable.
+                    ...(compareMode === 'ab' ? { runRole: 'fraim' } : {}),
                 };
                 this.runRegistry.create(run, {});
+                // Issue #442: create the Direct (B) run before spawning either process
+                // so we can cross-link both runs via compareRunId before any events arrive.
+                // directMsg is the plain user instructions — no FRAIM invocation prefix.
+                const directMsg = compareMode === 'ab'
+                    ? ((req.body.directInstructions || '').trim() || message)
+                    : message;
+                let directRun;
+                if (compareMode === 'ab') {
+                    const directTimestamp = new Date().toISOString();
+                    directRun = {
+                        id: (0, crypto_1.randomUUID)(),
+                        jobId: 'direct',
+                        hostId,
+                        projectPath,
+                        status: 'running',
+                        createdAt: directTimestamp,
+                        updatedAt: directTimestamp,
+                        messages: [(0, hosts_1.createHubMessage)('manager', directMsg)],
+                        events: [(0, hosts_1.createHubEvent)('system', `Starting direct (no FRAIM) ${hostId} in ${projectPath}`)],
+                        currentPhase: null,
+                        phaseHistory: [],
+                        totals: emptyTotals(),
+                        lastStatusChangeAt: directTimestamp,
+                        personaKey: null,
+                        runRole: 'direct',
+                        compareRunId: run.id,
+                    };
+                    // Back-link the FRAIM run to the Direct run.
+                    this.runRegistry.update(run.id, (current) => {
+                        current.compareRunId = directRun.id;
+                    });
+                    this.runRegistry.create(directRun, {});
+                }
                 const child = this.hostRuntime.startRun(hostId, projectPath, message, {
                     onEvent: (event, channel) => {
                         this.runRegistry.update(run.id, (current) => {
@@ -711,6 +828,37 @@ class AiHubServer {
                     },
                 });
                 this.runRegistry.create(run, child);
+                // Issue #442: spawn the Direct run via startDirectRun so CliHostRuntime
+                // uses buildDirectStartPlan (--strict-mcp-config, raw stdin) rather than
+                // the FRAIM-wrapping buildStartPlan path.
+                if (directRun) {
+                    const directId = directRun.id;
+                    const directChild = this.hostRuntime.startDirectRun(hostId, directMsg, projectPath, {
+                        onEvent: (event, channel) => {
+                            this.runRegistry.update(directId, (current) => {
+                                if (event.sessionId)
+                                    current.sessionId = event.sessionId;
+                                if (event.message)
+                                    current.messages.push((0, hosts_1.createHubMessage)('employee', event.message));
+                                if (event.raw)
+                                    current.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
+                                if (event.agentIdentity)
+                                    applyAgentIdentitySignal(current, event.agentIdentity);
+                                if (event.usage)
+                                    applyUsageSignal(current, event.usage);
+                            });
+                        },
+                        onExit: (exitCode) => {
+                            this.runRegistry.update(directId, (current) => {
+                                current.exitCode = exitCode;
+                                current.status = exitCode === 0 ? 'completed' : 'failed';
+                                current.events.push((0, hosts_1.createHubEvent)('system', `Direct run exited with code ${exitCode ?? 'unknown'}.`));
+                            });
+                            this.runRegistry.dispose(directId);
+                        },
+                    });
+                    this.runRegistry.create(directRun, directChild);
+                }
                 const existingPreferences = this.preferencesStore.load(projectPath);
                 this.preferencesStore.remember({
                     ...existingPreferences,
@@ -718,7 +866,11 @@ class AiHubServer {
                     employeeId: hostId,
                     recentJobIds: existingPreferences.recentJobIds,
                 }, jobId);
-                res.status(201).json(this.enrichRunForResponse(run));
+                const fraimRunEnriched = this.enrichRunForResponse(this.runRegistry.get(run.id) ?? run);
+                const responsePayload = directRun
+                    ? { ...fraimRunEnriched, compareRun: this.enrichRunForResponse(directRun) }
+                    : fraimRunEnriched;
+                res.status(201).json(responsePayload);
                 // Background sync: refresh the local FRAIM catalog so the next job
                 // picker load sees any jobs that were added or updated since last run.
                 try {
@@ -784,6 +936,54 @@ class AiHubServer {
                 res.status(400).json({ error: error instanceof Error ? error.message : 'Could not continue run.' });
             }
         });
+        // Issue #442: continue the Direct (B) run without FRAIM MCP servers.
+        this.app.post('/api/ai-hub/runs/:runId/direct-messages', (req, res) => {
+            try {
+                const run = this.runRegistry.get(req.params.runId);
+                if (!run)
+                    return res.status(404).json({ error: 'Run not found.' });
+                if (run.runRole !== 'direct')
+                    return res.status(400).json({ error: 'Run is not a Direct run.' });
+                if (!run.sessionId)
+                    return res.status(409).json({ error: 'Direct run does not have a resumable session yet.' });
+                const message = (req.body.message || '').trim();
+                if (!message)
+                    return res.status(400).json({ error: 'Message is required.' });
+                this.runRegistry.update(run.id, (current) => {
+                    current.status = 'running';
+                    current.messages.push((0, hosts_1.createHubMessage)('manager', message));
+                });
+                this.runRegistry.create(run, {});
+                const child = this.hostRuntime.continueDirectRun(run.hostId, run.sessionId, message, run.projectPath, {
+                    onEvent: (event, channel) => {
+                        this.runRegistry.update(run.id, (current) => {
+                            if (event.sessionId)
+                                current.sessionId = event.sessionId;
+                            if (event.message)
+                                current.messages.push((0, hosts_1.createHubMessage)('employee', event.message));
+                            if (event.raw)
+                                current.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
+                            if (event.usage)
+                                applyUsageSignal(current, event.usage);
+                        });
+                    },
+                    onExit: (exitCode) => {
+                        this.runRegistry.update(run.id, (current) => {
+                            current.exitCode = exitCode;
+                            current.status = exitCode === 0 ? 'completed' : 'failed';
+                            current.events.push((0, hosts_1.createHubEvent)('system', `Direct run exited with code ${exitCode ?? 'unknown'}.`));
+                        });
+                        this.runRegistry.dispose(run.id);
+                    },
+                });
+                this.runRegistry.create(run, child);
+                const refreshed = this.runRegistry.get(run.id);
+                res.json(refreshed ? this.enrichRunForResponse(refreshed) : refreshed);
+            }
+            catch (error) {
+                res.status(400).json({ error: error instanceof Error ? error.message : 'Could not continue Direct run.' });
+            }
+        });
         this.app.get('/api/ai-hub/runs/:runId', (req, res) => {
             const run = this.runRegistry.get(req.params.runId);
             if (!run) {

package/dist/src/cli/commands/init-project.js

@@ -19,6 +19,8 @@ const fraim_gitignore_1 = require("../utils/fraim-gitignore");
 const agent_adapters_1 = require("../utils/agent-adapters");
 const project_fraim_paths_1 = require("../../core/utils/project-fraim-paths");
 const project_bootstrap_1 = require("../utils/project-bootstrap");
+const config_loader_1 = require("../../core/config-loader");
+const github_workflow_sync_1 = require("../utils/github-workflow-sync");
 const checkGlobalSetup = () => {
     const fraimUserDir = process.env.FRAIM_USER_DIR || path_1.default.join(os_1.default.homedir(), '.fraim');
     const globalConfigPath = path_1.default.join(fraimUserDir, 'config.json');
@@ -63,7 +65,6 @@ const findProjectFile = (filename) => {
 exports.findProjectFile = findProjectFile;
 ;
 const installGitHubWorkflows = (projectRoot) => {
-    const workflowsDir = path_1.default.join(projectRoot, '.github', 'workflows');
     const registryDir = (0, exports.findProjectFile)('registry');
     const sourceDir = path_1.default.join(registryDir, 'github', 'workflows');
     if (!fs_1.default.existsSync(sourceDir)) {
@@ -73,21 +74,22 @@ const installGitHubWorkflows = (projectRoot) => {
         console.log(chalk_1.default.gray(`Process cwd: ${process.cwd()}`));
         return;
     }
-    if (!fs_1.default.existsSync(workflowsDir)) {
-        fs_1.default.mkdirSync(workflowsDir, { recursive: true });
+    const config = fs_1.default.existsSync((0, project_fraim_paths_1.getWorkspaceConfigPath)(projectRoot))
+        ? (0, config_loader_1.loadFraimConfig)((0, project_fraim_paths_1.getWorkspaceConfigPath)(projectRoot))
+        : null;
+    if (!(0, github_workflow_sync_1.isGitHubWorkflowAutomationEnabled)(config)) {
+        console.log(chalk_1.default.gray('GitHub workflow automation disabled or not configured; skipping managed workflow install.'));
+        return;
     }
-    const workflowFiles = ['phase-change.yml', 'status-change.yml', 'sync-on-pr-review.yml'];
-    workflowFiles.forEach((file) => {
-        const sourcePath = path_1.default.join(sourceDir, file);
-        const destPath = path_1.default.join(workflowsDir, file);
-        if (fs_1.default.existsSync(sourcePath)) {
-            fs_1.default.copyFileSync(sourcePath, destPath);
-            console.log(chalk_1.default.green(`Installed workflow: .github/workflows/${file}`));
-        }
-        else {
-            console.log(chalk_1.default.yellow(`Warning: Workflow not found in registry: ${file}`));
-        }
+    const bundle = (0, github_workflow_sync_1.loadLocalGitHubWorkflowBundle)(registryDir);
+    const result = (0, github_workflow_sync_1.reconcileGitHubWorkflowAssets)({
+        projectRoot,
+        files: bundle,
+        config
     });
+    for (const line of (0, github_workflow_sync_1.formatGitHubWorkflowSyncSummary)(result)) {
+        console.log(chalk_1.default.green(line));
+    }
 };
 const createGitHubLabels = (projectRoot) => {
     try {
@@ -137,6 +139,9 @@ function formatPlatformLabel(provider) {
             return provider.toUpperCase();
     }
 }
+function isMinimalConversationMode(mode) {
+    return mode === 'conversational';
+}
 const runInitProject = async (options = {}) => {
     console.log(chalk_1.default.blue('Initializing FRAIM project...'));
     const failHard = options.failHard ?? 'exit';
@@ -187,7 +192,9 @@ const runInitProject = async (options = {}) => {
         const detection = (0, platform_detection_1.detectPlatformFromGit)();
         if (detection.provider !== 'unknown' && detection.repository) {
             result.repositoryDetected = true;
-            result.projectName = detection.repository.name || projectName;
+            if (!isMinimalConversationMode(preferredMode)) {
+                result.projectName = detection.repository.name || projectName;
+            }
             const jiraConfig = globalSetup.providerConfigs?.jiraConfig;
             if (preferredMode === 'split' && globalSetup.tokens?.jira && jiraConfig?.baseUrl) {
                 result.issueTrackingDetected = true;
@@ -200,26 +207,31 @@ const runInitProject = async (options = {}) => {
                     result.mode = 'integrated';
                     result.warnings.push('Split mode is not fully configured for this repo yet, so issue tracking will fall back to the repository provider during onboarding.');
                 }
-                console.log(chalk_1.default.blue(`   Platform: ${formatPlatformLabel(detection.provider)}`));
-            }
-            const repo = detection.repository;
-            if (repo.owner && repo.name) {
-                console.log(chalk_1.default.gray(`   Repository: ${repo.owner}/${repo.name}`));
-            }
-            else if (repo.organization && repo.project && repo.name) {
-                console.log(chalk_1.default.gray(`   Organization: ${repo.organization}`));
-                console.log(chalk_1.default.gray(`   Project: ${repo.project}`));
-                console.log(chalk_1.default.gray(`   Repository: ${repo.name}`));
+                if (!isMinimalConversationMode(preferredMode)) {
+                    console.log(chalk_1.default.blue(`   Platform: ${formatPlatformLabel(detection.provider)}`));
+                }
             }
-            else if (repo.namespace && repo.name) {
-                console.log(chalk_1.default.gray(`   Namespace: ${repo.namespace || '(none)'}`));
-                console.log(chalk_1.default.gray(`   Repository: ${repo.name}`));
+            if (!isMinimalConversationMode(preferredMode)) {
+                const repo = detection.repository;
+                if (repo.owner && repo.name) {
+                    console.log(chalk_1.default.gray(`   Repository: ${repo.owner}/${repo.name}`));
+                }
+                else if (repo.organization && repo.project && repo.name) {
+                    console.log(chalk_1.default.gray(`   Organization: ${repo.organization}`));
+                    console.log(chalk_1.default.gray(`   Project: ${repo.project}`));
+                    console.log(chalk_1.default.gray(`   Repository: ${repo.name}`));
+                }
+                else if (repo.namespace && repo.name) {
+                    console.log(chalk_1.default.gray(`   Namespace: ${repo.namespace || '(none)'}`));
+                    console.log(chalk_1.default.gray(`   Repository: ${repo.name}`));
+                }
             }
         }
         else {
             result.mode = 'conversational';
-            result.warnings.push('No git remote detected. FRAIM fell back to conversational project setup.');
-            console.log(chalk_1.default.yellow('   No git remote detected. Falling back to conversational mode.'));
+            if (!isMinimalConversationMode(preferredMode)) {
+                console.log(chalk_1.default.yellow('   Starting conversational project setup.'));
+            }
         }
         result.warnings.push(`${configDisplayPath} was not created by init-project. The manager \`project-onboarding\` job is the only supported config-writing path.`);
     }
@@ -236,15 +248,15 @@ const runInitProject = async (options = {}) => {
         }
     });
     const ignoreUpdate = (0, fraim_gitignore_1.ensureFraimSyncedContentLocallyExcluded)(projectRoot);
-    if (ignoreUpdate.gitInfoExcludeUpdated) {
+    if (ignoreUpdate.gitInfoExcludeUpdated && !isMinimalConversationMode(result.mode)) {
         console.log(chalk_1.default.green('Updated .git/info/exclude FRAIM managed block'));
     }
-    if (ignoreUpdate.gitignoreUpdated) {
+    if (ignoreUpdate.gitignoreUpdated && !isMinimalConversationMode(result.mode)) {
         console.log(chalk_1.default.green('Removed legacy FRAIM sync block from .gitignore'));
     }
     const detection = (0, platform_detection_1.detectPlatformFromGit)();
-    if (detection.provider === 'github') {
-        console.log(chalk_1.default.blue('\nSetting up GitHub workflows and labels...'));
+    if (detection.provider === 'github' && !isMinimalConversationMode(result.mode)) {
+        console.log(chalk_1.default.blue('\nSetting up GitHub labels...'));
         installGitHubWorkflows(projectRoot);
         createGitHubLabels(projectRoot);
         result.repositoryDetected = true;
@@ -256,14 +268,16 @@ const runInitProject = async (options = {}) => {
     else {
         result.warnings.push('Sync was skipped for this run.');
     }
-    const codexAvailable = (0, ide_detector_1.detectInstalledIDEs)().some((ide) => ide.configType === 'codex');
+    const codexAvailable = (0, ide_detector_1.detectInstalledIDEs)().some((ide) => ide.configType === 'codex') ||
+        (0, ide_detector_1.detectInstalledIDEs)('cli-runnable').some((ide) => ide.configType === 'codex');
     if (codexAvailable) {
         const codexLocalResult = (0, codex_local_config_1.ensureCodexLocalConfig)(projectRoot);
         const status = codexLocalResult.created ? 'Created' : codexLocalResult.updated ? 'Updated' : 'Verified';
         console.log(chalk_1.default.green(`${status} project Codex config at ${codexLocalResult.path}`));
     }
     // Enable token telemetry for Claude Code (user-level, applies to all projects)
-    const claudeCodeAvailable = (0, ide_detector_1.detectInstalledIDEs)().some((ide) => ide.configType === 'claude-code');
+    const claudeCodeAvailable = (0, ide_detector_1.detectInstalledIDEs)().some((ide) => ide.configType === 'claude-code') ||
+        (0, ide_detector_1.detectInstalledIDEs)('cli-runnable').some((ide) => ide.configType === 'claude-code');
     if (claudeCodeAvailable) {
         (0, claude_code_telemetry_1.ensureClaudeCodeTelemetryEnv)();
     }