fraim-hub 2.0.275 → 2.0.277

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

@@ -15,6 +15,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
 const resolve_phase_edge_1 = require("../core/resolve-phase-edge");
+const pack_home_1 = require("../cli/utils/pack-home");
 // Directories scanned for employee jobs at runtime, in lowest-to-highest
 // precedence order. Later entries win on {categoryId, jobId} collision.
 //
@@ -24,27 +25,12 @@ const resolve_phase_edge_1 = require("../core/resolve-phase-edge");
 //   - <project>/fraim/ai-employee/jobs/<category>/           - synced baseline
 //   - <project>/fraim/personalized-employee/jobs/<category>/ - taught/customized override
 // Only the personalized-employee layer is "personalized" (issue #566).
-// Issue #1002: the machine-level layers are added here so a capability authored
-// at the manager level is DISCOVERABLE, not merely resolvable by exact name.
-// Order matters and mirrors LocalRegistryResolver.resolveFile precedence
-// inverted, because later entries win on a {categoryId, jobId} collision:
-//   synced baseline < company cache < manager synced cache < manager local < project
-// A job that resolves from the manager level must therefore also DISPLAY as the
-// manager's, otherwise the rail would show a baseline job the runtime never runs.
 const EMPLOYEE_JOB_LAYERS = [
     { segments: ['ai-employee', 'jobs'], personalized: false },
-    { base: 'user', segments: ['org', 'jobs'], personalized: true, scope: 'org' },
-    { base: 'user', segments: ['manager', 'jobs'], personalized: true, scope: 'manager' },
-    { base: 'user', segments: ['personalized-employee', 'jobs'], personalized: true, scope: 'manager' },
-    { segments: ['personalized-employee', 'jobs'], personalized: true, scope: 'project' },
 ];
 // Manager templates use the matching layer model.
 const MANAGER_JOB_LAYERS = [
     { segments: ['ai-manager', 'jobs'], personalized: false },
-    { base: 'user', segments: ['org', 'manager-jobs'], personalized: true, scope: 'org' },
-    { base: 'user', segments: ['manager', 'manager-jobs'], personalized: true, scope: 'manager' },
-    { base: 'user', segments: ['personalized-employee', 'manager-jobs'], personalized: true, scope: 'manager' },
-    { segments: ['personalized-employee', 'manager-jobs'], personalized: true, scope: 'project' },
 ];
 const REGISTRY_EMPLOYEE_JOB_LAYERS = [
     { base: 'project', segments: ['registry', 'jobs', 'ai-employee'], personalized: false },
@@ -108,7 +94,6 @@ function resolveExtendedStubPath(projectPath, extendsValue) {
         path_1.default.join(projectPath, 'fraim', 'ai-manager', 'jobs'),
         path_1.default.join(projectPath, 'registry', 'jobs', 'ai-employee'),
         path_1.default.join(projectPath, 'registry', 'jobs', 'ai-manager'),
-        path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'ai-employee', 'jobs'),
     ];
     for (const root of candidateRoots) {
         const candidate = path_1.default.join(root, `${relative}.md`);
@@ -185,13 +170,13 @@ function readMarkdownFileNames(dirPath) {
  * as `~/.fraim/...` rather than as a long `../../..` walk out of the project,
  * which is what path.relative would otherwise produce for a user-level layer.
  */
-function stubDisplayPath(filePath, projectPath, userLevel) {
-    if (!userLevel)
+function stubDisplayPath(filePath, projectPath, displayRoot, displayPrefix) {
+    if (!displayRoot || !displayPrefix)
         return toPosix(path_1.default.relative(projectPath, filePath));
-    const rel = toPosix(path_1.default.relative((0, project_fraim_paths_1.getUserFraimDirPath)(), filePath));
-    return (0, project_fraim_paths_1.getUserFraimDisplayPath)(rel);
+    const rel = toPosix(path_1.default.relative(displayRoot, filePath));
+    return rel ? `${displayPrefix.replace(/\/$/, '')}/${rel}` : displayPrefix;
 }
-function parseJobStub(filePath, categoryId, categoryLabel, projectPath, personalized, scope, userLevel) {
+function parseJobStub(filePath, categoryId, categoryLabel, projectPath, personalized, scope, displayRoot, displayPrefix) {
     const content = fs_1.default.readFileSync(filePath, 'utf8');
     const fileName = path_1.default.basename(filePath, '.md');
     const frontmatter = readJobFrontmatter(filePath);
@@ -206,12 +191,12 @@ function parseJobStub(filePath, categoryId, categoryLabel, projectPath, personal
         categoryLabel,
         intent,
         outcome,
-        stubPath: stubDisplayPath(filePath, projectPath, userLevel),
+        stubPath: stubDisplayPath(filePath, projectPath, displayRoot, displayPrefix),
         personalized: !!personalized,
         ...(scope ? { scope } : {}),
     };
 }
-function parseManagerStub(filePath, groupId, groupLabel, projectPath, scope, userLevel) {
+function parseManagerStub(filePath, groupId, groupLabel, projectPath, scope, displayRoot, displayPrefix) {
     const content = fs_1.default.readFileSync(filePath, 'utf8');
     const fileName = path_1.default.basename(filePath, '.md');
     const frontmatter = readJobFrontmatter(filePath);
@@ -223,7 +208,7 @@ function parseManagerStub(filePath, groupId, groupLabel, projectPath, scope, use
         groupId,
         groupLabel,
         intent,
-        stubPath: stubDisplayPath(filePath, projectPath, userLevel),
+        stubPath: stubDisplayPath(filePath, projectPath, displayRoot, displayPrefix),
         ...(scope ? { scope } : {}),
     };
 }
@@ -262,10 +247,10 @@ function summarizeProject(projectPath) {
     };
 }
 function resolveLayerRoot(projectPath, layer) {
+    if (layer.root)
+        return layer.root;
     if (layer.base === 'project')
         return path_1.default.join(projectPath, ...layer.segments);
-    if (layer.base === 'user')
-        return path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), ...layer.segments);
     return path_1.default.join((0, project_fraim_paths_1.getWorkspaceFraimDir)(projectPath), ...layer.segments);
 }
 function discoverLayers(projectPath, layers) {
@@ -279,26 +264,37 @@ function discoverLayers(projectPath, layers) {
                 categoryDir: path_1.default.join(layerRoot, categoryName),
                 personalized: layer.personalized,
                 scope: layer.scope,
-                userLevel: layer.base === 'user',
+                displayRoot: layer.displayRoot,
+                displayPrefix: layer.displayPrefix,
             });
         }
     }
     return out;
 }
+function personalizedLayerSegments(projectPath, capabilityDir) {
+    return (0, pack_home_1.personalizedCapabilityReadRoots)(projectPath, capabilityDir).map((root) => ({
+        root: root.capabilityRoot,
+        segments: [],
+        personalized: true,
+        scope: root.scope,
+        displayRoot: root.displayRoot,
+        displayPrefix: root.displayPrefix,
+    }));
+}
 function discoverEmployeeJobs(projectPath, options = {}) {
     const project = summarizeProject(projectPath);
     if (!project.exists || (!project.hasFraim && !options.includeRegistry))
         return [];
     const layers = discoverLayers(projectPath, options.includeRegistry
-        ? [...REGISTRY_EMPLOYEE_JOB_LAYERS, ...EMPLOYEE_JOB_LAYERS]
-        : EMPLOYEE_JOB_LAYERS);
+        ? [...REGISTRY_EMPLOYEE_JOB_LAYERS, ...EMPLOYEE_JOB_LAYERS, ...personalizedLayerSegments(projectPath, 'jobs')]
+        : [...EMPLOYEE_JOB_LAYERS, ...personalizedLayerSegments(projectPath, 'jobs')]);
     // Group by categoryId so all layers contribute to the same labelled category.
     const jobsByKey = new Map();
     for (const layer of layers) {
         const categoryLabel = humanizeName(layer.categoryId);
         for (const fileName of readMarkdownFileNames(layer.categoryDir)) {
             const filePath = path_1.default.join(layer.categoryDir, fileName);
-            const job = parseJobStub(filePath, layer.categoryId, categoryLabel, projectPath, layer.personalized, layer.scope, layer.userLevel);
+            const job = parseJobStub(filePath, layer.categoryId, categoryLabel, projectPath, layer.personalized, layer.scope, layer.displayRoot, layer.displayPrefix);
             // Later layers override earlier layers on {category, jobId} collision —
             // personalized-employee wins over the synced ai-employee baseline. The
             // winning job carries its own layer's `personalized` flag (issue #566).
@@ -317,14 +313,14 @@ function discoverManagerTemplates(projectPath, options = {}) {
     if (!project.exists || (!project.hasFraim && !options.includeRegistry))
         return [];
     const layers = discoverLayers(projectPath, options.includeRegistry
-        ? [...REGISTRY_MANAGER_JOB_LAYERS, ...MANAGER_JOB_LAYERS]
-        : MANAGER_JOB_LAYERS);
+        ? [...REGISTRY_MANAGER_JOB_LAYERS, ...MANAGER_JOB_LAYERS, ...personalizedLayerSegments(projectPath, 'manager-jobs')]
+        : [...MANAGER_JOB_LAYERS, ...personalizedLayerSegments(projectPath, 'manager-jobs')]);
     const templatesByKey = new Map();
     for (const layer of layers) {
         const groupLabel = humanizeName(layer.categoryId);
         for (const fileName of readMarkdownFileNames(layer.categoryDir)) {
             const filePath = path_1.default.join(layer.categoryDir, fileName);
-            const template = parseManagerStub(filePath, layer.categoryId, groupLabel, projectPath, layer.scope, layer.userLevel);
+            const template = parseManagerStub(filePath, layer.categoryId, groupLabel, projectPath, layer.scope, layer.displayRoot, layer.displayPrefix);
             templatesByKey.set(`${template.groupId}::${template.id}`, template);
         }
     }
@@ -407,6 +403,8 @@ function findJobStubPath(projectPath, jobId) {
     const layers = discoverLayers(projectPath, [
         ...EMPLOYEE_JOB_LAYERS,
         ...MANAGER_JOB_LAYERS,
+        ...personalizedLayerSegments(projectPath, 'jobs'),
+        ...personalizedLayerSegments(projectPath, 'manager-jobs'),
     ]);
     let resolved = null;
     for (const layer of layers) {
@@ -520,8 +518,8 @@ function getAiHubCategories(projectPath, options = {}) {
         return [];
     // A category is any directory found at any layer; deduplicate by id.
     const layers = discoverLayers(projectPath, options.includeRegistry
-        ? [...REGISTRY_EMPLOYEE_JOB_LAYERS, ...EMPLOYEE_JOB_LAYERS]
-        : EMPLOYEE_JOB_LAYERS);
+        ? [...REGISTRY_EMPLOYEE_JOB_LAYERS, ...EMPLOYEE_JOB_LAYERS, ...personalizedLayerSegments(projectPath, 'jobs')]
+        : [...EMPLOYEE_JOB_LAYERS, ...personalizedLayerSegments(projectPath, 'jobs')]);
     const seen = new Map();
     for (const layer of layers) {
         if (!seen.has(layer.categoryId)) {

package/dist/src/ai-hub/configured-agent-command.js

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseConfiguredCommand = parseConfiguredCommand;
+exports.describeConfiguredCommandInvocationProblem = describeConfiguredCommandInvocationProblem;
+exports.commandContainsLiteralSecret = commandContainsLiteralSecret;
+exports.decorateHostPlanWithConfiguredAgent = decorateHostPlanWithConfiguredAgent;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
+const BASH_ENV_PREFIX = /^([A-Za-z_][A-Za-z0-9_]*)=(?:\$\([^)]*\)|"[^"]*"|'[^']*'|\S*)\s+/;
+// The value may be a parenthesized PowerShell expression followed by a
+// property-access chain (e.g. `(Get-Content ... | ConvertFrom-Json).api_key`),
+// a quoted string, or a bare token — always terminated by the statement `;`.
+const POWERSHELL_ENV_PREFIX = /^\$env:[A-Za-z_][A-Za-z0-9_]*\s*=\s*(?:\([^)]*\)(?:\.[A-Za-z_][A-Za-z0-9_]*)*|"[^"]*"|'[^']*'|\S+?)\s*;\s*/;
+function parseConfiguredCommand(runner, commandText) {
+    let rest = String(commandText || '').trim();
+    const prefixPattern = runner === 'powershell' ? POWERSHELL_ENV_PREFIX : BASH_ENV_PREFIX;
+    let prefixEnd = 0;
+    while (true) {
+        const match = rest.slice(prefixEnd).match(prefixPattern);
+        if (!match)
+            break;
+        prefixEnd += match[0].length;
+    }
+    const envPrefixText = rest.slice(0, prefixEnd).trim();
+    const invocation = rest.slice(prefixEnd).trim();
+    const tokens = tokenizeShellLike(invocation);
+    return { envPrefixText, extraArgs: tokens.slice(1), invocationHead: tokens[0] || '' };
+}
+// Reviewer finding (PR #1209, Round 3): parseConfiguredCommand's leniency is
+// intentional for *parsing* (it never throws), but that leniency means a
+// structurally wrong command — most dangerously a shell built-in like `.`
+// (source) or `source` at the head, meant to load a setup script into the
+// current shell — parses "successfully" into a garbage invocationHead that
+// decorateHostPlanWithConfiguredAgent then silently discards, appending only
+// the path/args that followed it as bogus positional arguments to the real
+// agent binary instead of ever sourcing the script. Since the invocation
+// head is always discarded and replaced with Hub's own known base binary,
+// the only way to catch this class of error is to check, at readiness time,
+// that what the user typed there actually was that same base binary — not
+// to attempt to execute or otherwise interpret it.
+function describeConfiguredCommandInvocationProblem(parsed, baseHostId) {
+    if (!parsed.invocationHead) {
+        return 'Command has no invocation to run after the environment prefix.';
+    }
+    if (parsed.invocationHead !== baseHostId) {
+        return `Command must invoke "${baseHostId}" (found "${parsed.invocationHead}"). A setup script should be registered as a setup script, not composed into this field — see hub-configured-agent-setup.md.`;
+    }
+    return null;
+}
+function tokenizeShellLike(text) {
+    const tokens = [];
+    const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+    let match;
+    while ((match = re.exec(text)) !== null) {
+        tokens.push(match[1] ?? match[2] ?? match[3]);
+    }
+    return tokens;
+}
+// Issue #1201 (R2.3): UX safety net only — flags what pattern-matches as a
+// literal high-entropy secret pasted into the command field. Not a substitute
+// for the routing skill never generating such a command in the first place.
+const LITERAL_SECRET_TOKEN = /^[A-Za-z0-9+/_.=-]{20,}$/;
+function commandContainsLiteralSecret(commandText) {
+    for (const token of String(commandText || '').split(/\s+/)) {
+        const eq = token.indexOf('=');
+        if (eq <= 0)
+            continue;
+        const value = token.slice(eq + 1);
+        if (!value || value.startsWith('$') || value.startsWith('`') || value.startsWith('('))
+            continue;
+        if (LITERAL_SECRET_TOKEN.test(value))
+            return true;
+    }
+    return false;
+}
+// The env-prefix assignment is evaluated as a bash "temporary environment"
+// directly attached to the `exec` command on the same line (`VAR=$(...) exec
+// "$@"`), not as a separate statement before it. A bare `VAR=value` on its
+// own line only sets a local shell variable — it is NOT exported, so it
+// would silently vanish from the real binary's environment once `exec`
+// replaces this process image. Attaching it to the same command line is
+// exactly what a terminal user's `VAR=$(...) codex ...` already does.
+const BASH_LAUNCH_WRAPPER = [
+    '#!/usr/bin/env bash',
+    'set -e',
+    'if [ -n "$FRAIM_CONFIGURED_AGENT_ENV_PREFIX" ]; then',
+    '  eval "$FRAIM_CONFIGURED_AGENT_ENV_PREFIX exec \\"\\$@\\""',
+    'else',
+    '  exec "$@"',
+    'fi',
+    '',
+].join('\n');
+const POWERSHELL_LAUNCH_WRAPPER = [
+    '$ErrorActionPreference = "Stop"',
+    'if ($env:FRAIM_CONFIGURED_AGENT_ENV_PREFIX) {',
+    '  Invoke-Expression $env:FRAIM_CONFIGURED_AGENT_ENV_PREFIX',
+    '}',
+    '$exe = $args[0]',
+    'if ($args.Length -gt 1) { $rest = $args[1..($args.Length - 1)] } else { $rest = @() }',
+    '& $exe @rest',
+    'exit $LASTEXITCODE',
+    '',
+].join('\r\n');
+// Writes the small, fixed wrapper script that lets a configured-agent's
+// env-prefix (which may contain `$(...)`/`(...)` substitutions) resolve in a
+// real shell at spawn time, then `exec`s Hub's own required invocation with
+// the parsed extra CLI args appended. Content-checked so it self-heals like
+// any other FRAIM-generated artifact (issue #1206 precedent) rather than
+// silently going stale if regenerated with different logic.
+//
+// Security review (issue #1201): written under the per-user FRAIM home
+// (`getUserFraimDirPath()`), NOT `os.tmpdir()`. A predictable filename in a
+// shared, world-writable OS temp directory is a symlink-race target on
+// multi-user machines — another local user could pre-place a symlink at the
+// predictable path, and `fs.writeFileSync` would follow it and overwrite an
+// arbitrary file the *victim* user can write to. The per-user FRAIM home is
+// not shared across OS accounts, closing that class of attack.
+function ensureConfiguredAgentLaunchWrapper(runner) {
+    const content = runner === 'bash' ? BASH_LAUNCH_WRAPPER : POWERSHELL_LAUNCH_WRAPPER;
+    const filePath = path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), runner === 'bash' ? 'hub-configured-agent-launch.sh' : 'hub-configured-agent-launch.ps1');
+    const existing = fs_1.default.existsSync(filePath) ? fs_1.default.readFileSync(filePath, 'utf8') : null;
+    if (existing !== content) {
+        fs_1.default.writeFileSync(filePath, content, { encoding: 'utf8', mode: 0o755 });
+    }
+    return filePath;
+}
+function decorateHostPlanWithConfiguredAgent(plan, agent, agentEnv = {}) {
+    if (!agent)
+        return plan;
+    const withEnv = { ...plan, env: { ...(plan.env || {}), ...agentEnv } };
+    if (!agent.command)
+        return withEnv;
+    const parsed = parseConfiguredCommand(agent.command.runner, agent.command.command);
+    if (!parsed.envPrefixText && parsed.extraArgs.length === 0)
+        return withEnv;
+    const wrapperPath = ensureConfiguredAgentLaunchWrapper(agent.command.runner);
+    const realInvocation = [plan.command, ...plan.args, ...parsed.extraArgs];
+    const decoratedEnv = { ...withEnv.env, FRAIM_CONFIGURED_AGENT_ENV_PREFIX: parsed.envPrefixText };
+    if (agent.command.runner === 'bash') {
+        return { ...withEnv, command: 'bash', args: [wrapperPath, ...realInvocation], env: decoratedEnv };
+    }
+    return {
+        ...withEnv,
+        command: 'powershell.exe',
+        args: ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', wrapperPath, ...realInvocation],
+        env: decoratedEnv,
+    };
+}

package/dist/src/ai-hub/configured-agents.js

@@ -3,18 +3,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AiHubConfiguredAgentStore = void 0;
+exports.describeConfiguredCommandInvocationProblem = exports.decorateHostPlanWithConfiguredAgent = exports.commandContainsLiteralSecret = exports.parseConfiguredCommand = exports.AiHubConfiguredAgentStore = void 0;
 exports.synthesizeDefaultConfiguredAgents = synthesizeDefaultConfiguredAgents;
 exports.checkConfiguredAgentAvailability = checkConfiguredAgentAvailability;
 exports.checkConfiguredAgentReadiness = checkConfiguredAgentReadiness;
 exports.projectConfiguredAgent = projectConfiguredAgent;
 exports.resolveConfiguredAgentForHost = resolveConfiguredAgentForHost;
 exports.resolveConfiguredAgentEnv = resolveConfiguredAgentEnv;
-exports.decorateHostPlanWithConfiguredAgent = decorateHostPlanWithConfiguredAgent;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
+const configured_agent_command_1 = require("./configured-agent-command");
 const VALID_HOSTS = ['codex', 'claude', 'gemini', 'copilot'];
 const ENV_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 function nowIso() {
@@ -48,6 +48,9 @@ function normalizeAgent(input) {
     const setupScript = normalizeSetupScript(input.setupScript);
     if (input.setupScript && !setupScript)
         return { ok: false, error: 'Setup script command is required.' };
+    const command = normalizeCommand(input.command);
+    if (input.command && !command)
+        return { ok: false, error: 'Command is required.' };
     const createdAt = input.createdAt || nowIso();
     return {
         ok: true,
@@ -57,6 +60,7 @@ function normalizeAgent(input) {
             ...(input.description && String(input.description).trim() ? { description: String(input.description).trim() } : {}),
             baseHostId,
             enabled: input.enabled !== false,
+            ...(command ? { command } : {}),
             ...(setupScript ? { setupScript } : {}),
             createdAt,
             updatedAt: nowIso(),
@@ -77,6 +81,24 @@ function normalizeSetupScript(value) {
         timeoutMs: typeof value.timeoutMs === 'number' && value.timeoutMs > 0 ? Math.min(value.timeoutMs, 120_000) : 30_000,
     };
 }
+// Issue #1201 (R2.1): the single-text-field setup surface. `runner` is an
+// internal execution detail — callers that omit it get the current platform's
+// default shell so the UI never has to ask the user to pick one.
+function normalizeCommand(value) {
+    if (!value)
+        return null;
+    const command = String(value.command || '').trim();
+    if (!command)
+        return null;
+    const runner = value.runner === 'bash' || value.runner === 'powershell'
+        ? value.runner
+        : (process.platform === 'win32' ? 'powershell' : 'bash');
+    return {
+        runner,
+        command,
+        timeoutMs: typeof value.timeoutMs === 'number' && value.timeoutMs > 0 ? Math.min(value.timeoutMs, 120_000) : 30_000,
+    };
+}
 function synthesizeDefaultConfiguredAgents(employees) {
     const timestamp = '1970-01-01T00:00:00.000Z';
     return employees
@@ -152,7 +174,12 @@ function checkConfiguredAgentAvailability(agent, employees, env = process.env) {
         reasons.push('Configured agent is disabled.');
     if (!employee?.available)
         reasons.push(`${employee?.label || agent.baseHostId} is not available on this machine.`);
-    if (agent.setupScript) {
+    if (agent.command) {
+        if (!agent.command.command.trim()) {
+            reasons.push('Command is empty.');
+        }
+    }
+    else if (agent.setupScript) {
         const command = agent.setupScript.command;
         const isPathLike = /[\\/]/.test(command) || /^[A-Za-z]:[\\/]/.test(command);
         if (isPathLike && !fs_1.default.existsSync(command)) {
@@ -160,13 +187,35 @@ function checkConfiguredAgentAvailability(agent, employees, env = process.env) {
         }
     }
     else if (!agent.id.endsWith('-default')) {
-        warnings.push('No setup script configured; this profile launches the base CLI unchanged.');
+        warnings.push('No command configured; this profile launches the base CLI unchanged.');
     }
     return { id: agent.id, label: agent.label, baseHostId: agent.baseHostId, enabled: agent.enabled, available: reasons.length === 0, reasons, warnings };
 }
 function checkConfiguredAgentReadiness(agent, employees, env = process.env) {
     const check = checkConfiguredAgentAvailability(agent, employees, env);
-    if (!check.available || !agent.setupScript)
+    if (!check.available)
+        return check;
+    if (agent.command) {
+        try {
+            const parsed = (0, configured_agent_command_1.parseConfiguredCommand)(agent.command.runner, agent.command.command);
+            const problem = (0, configured_agent_command_1.describeConfiguredCommandInvocationProblem)(parsed, agent.baseHostId);
+            if (problem) {
+                return { ...check, available: false, reasons: [...check.reasons, problem] };
+            }
+            return check;
+        }
+        catch (error) {
+            return {
+                ...check,
+                available: false,
+                reasons: [
+                    ...check.reasons,
+                    error instanceof Error ? error.message : 'Configured agent command could not be parsed.',
+                ],
+            };
+        }
+    }
+    if (!agent.setupScript)
         return check;
     try {
         resolveConfiguredAgentEnv(agent);
@@ -191,6 +240,7 @@ function projectConfiguredAgent(agent, employees) {
         ...(agent.description ? { description: agent.description } : {}),
         baseHostId: agent.baseHostId,
         enabled: agent.enabled,
+        ...(agent.command ? { command: { ...agent.command } } : {}),
         ...(agent.setupScript ? { setupScript: { ...agent.setupScript, args: [...(agent.setupScript.args || [])] } } : {}),
         createdAt: agent.createdAt,
         updatedAt: agent.updatedAt,
@@ -295,11 +345,13 @@ function filterSafeEnv(env) {
     }
     return safe;
 }
-function decorateHostPlanWithConfiguredAgent(plan, agent, agentEnv = {}) {
-    if (!agent)
-        return plan;
-    return {
-        ...plan,
-        env: { ...(plan.env || {}), ...agentEnv },
-    };
-}
+// Issue #1201: command parsing, secret detection, and launch decoration for
+// the single-command configured-agent surface live in their own module
+// (kept a cohesive, separately-testable unit rather than growing this file
+// past the 500-line quality threshold) — re-exported here so existing
+// callers importing from `./configured-agents` are unaffected.
+var configured_agent_command_2 = require("./configured-agent-command");
+Object.defineProperty(exports, "parseConfiguredCommand", { enumerable: true, get: function () { return configured_agent_command_2.parseConfiguredCommand; } });
+Object.defineProperty(exports, "commandContainsLiteralSecret", { enumerable: true, get: function () { return configured_agent_command_2.commandContainsLiteralSecret; } });
+Object.defineProperty(exports, "decorateHostPlanWithConfiguredAgent", { enumerable: true, get: function () { return configured_agent_command_2.decorateHostPlanWithConfiguredAgent; } });
+Object.defineProperty(exports, "describeConfiguredCommandInvocationProblem", { enumerable: true, get: function () { return configured_agent_command_2.describeConfiguredCommandInvocationProblem; } });

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

@@ -47,7 +47,10 @@ const pack_home_1 = require("../cli/utils/pack-home");
 //     whose item.type === 'mcp_tool_call' and item.tool === 'seekMentoring'
 //     (Codex separates the MCP server name from the tool name).
 function parseSeekMentoringSignal(line) {
-    if (!line.includes('seekMentoring'))
+    // Issue #1264: case-insensitive so a host that flattens the tool name to
+    // all-lowercase (e.g. "fraim_seekmentoring") still reaches the JSON parse
+    // and isFraimTool checks below instead of being dropped by this fast gate.
+    if (!line.toLowerCase().includes('seekmentoring'))
         return null;
     let parsed;
     try {
@@ -301,6 +304,68 @@ function parseAgentIdentitySignal(line) {
     }
     return null;
 }
+// Issue #1264 (R3): defense-in-depth diagnostic. A tool call that carries a
+// submit-phase reviewHandoff (reviewRequired: true) under a name isFraimTool
+// cannot resolve to 'seekMentoring' — even after the flattened-lowercase
+// matching above — means the Hub is about to silently drop a real review
+// handoff, the #1264/#1265 failure mode for a naming shape not yet
+// anticipated. Returns a human-readable diagnostic surfaced via the existing
+// `hostError` channel (already rendered, non-droppable) instead of inventing
+// new UI. Scoped to lines that already carry a `reviewHandoff` key so it
+// never fires for submits that legitimately have none.
+function detectUnrecognizedReviewHandoffCall(line) {
+    if (!line.toLowerCase().includes('reviewhandoff'))
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== 'object' || parsed === null)
+        return null;
+    const obj = parsed;
+    const check = (rawName, rawArgs) => {
+        if (isFraimTool(rawName, 'seekMentoring'))
+            return null;
+        const args = normalizeToolArgs(rawArgs);
+        if (!args)
+            return null;
+        const reviewHandoff = extractReviewHandoffFromArgs(args);
+        if (!reviewHandoff || !reviewHandoff.reviewRequired)
+            return null;
+        const name = typeof rawName === 'string' ? rawName : String(rawName);
+        return `FRAIM review handoff detected in host output under an unrecognized tool name ("${name}") — the Hub could not project it onto this conversation. File a FRAIM issue naming this exact tool name so recognition can be extended.`;
+    };
+    if ((obj.type === 'item.started' || obj.type === 'item.completed') && typeof obj.item === 'object' && obj.item !== null) {
+        const item = obj.item;
+        if (item.type === 'mcp_tool_call') {
+            const hit = check(item.tool, item.arguments);
+            if (hit)
+                return hit;
+        }
+    }
+    const candidates = [obj];
+    if (Array.isArray(obj.content))
+        candidates.push(...obj.content);
+    if (typeof obj.message === 'object' && obj.message !== null) {
+        const msg = obj.message;
+        if (Array.isArray(msg.content))
+            candidates.push(...msg.content);
+    }
+    for (const candidate of candidates) {
+        if (typeof candidate !== 'object' || candidate === null)
+            continue;
+        const c = candidate;
+        if (c.type !== 'tool_use' && c.type !== 'function_call')
+            continue;
+        const hit = check(readToolName(c), c.input || c.arguments || c.parameters);
+        if (hit)
+            return hit;
+    }
+    return null;
+}
 function readAgentFromArgs(args) {
     if (!args || typeof args.agent !== 'object' || args.agent === null)
         return null;
@@ -335,7 +400,27 @@ function canonicalToolName(rawName) {
     return byDoubleUnderscore.split(/[./:]/).filter(Boolean).pop() || null;
 }
 function isFraimTool(rawName, canonicalName) {
-    return canonicalToolName(rawName) === canonicalName;
+    if (canonicalToolName(rawName) === canonicalName)
+        return true;
+    return isFlattenedFraimToolName(rawName, canonicalName);
+}
+// Issue #1264: the "Codex Azure Script" configured agent (MCP server
+// codex_apps) flattens tool identity into a single lowercase, separator-less
+// token instead of a qualifier syntax canonicalToolName's __/./\//: split can
+// find (e.g. "fraim_seekmentoring", "fraim_get_fraim_job", "fraim_fraim_connect"
+// — confirmed verbatim in the 2026-08-21 event log). Match that exact flattened
+// shape, plus the bare lowercase form, case-insensitively — scoped only to the
+// three known canonical FRAIM tool identities so an unrelated tool name is
+// never accepted (#982's case-sensitivity intent is preserved for everything
+// that isn't a legitimate flattened/qualified form of a known FRAIM tool).
+function isFlattenedFraimToolName(rawName, canonicalName) {
+    if (typeof rawName !== 'string')
+        return false;
+    const trimmedLower = rawName.trim().toLowerCase();
+    if (!trimmedLower)
+        return false;
+    const lowerCanonical = canonicalName.toLowerCase();
+    return trimmedLower === lowerCanonical || trimmedLower === `fraim_${lowerCanonical}`;
 }
 function readFraimJobFromArgs(rawArgs) {
     const args = normalizeToolArgs(rawArgs);
@@ -1534,8 +1619,11 @@ function parseHostLine(hostId, line) {
     const fraimJob = parseFraimJobLoadSignal(trimmed);
     const usage = parseUsageSignal(trimmed);
     const agentIdentity = parseAgentIdentitySignal(trimmed);
+    // Issue #1264 (R3): only worth checking when seekMentoring itself did not
+    // already resolve — a recognized call has nothing to diagnose.
+    const unrecognizedReviewHandoffError = seekMentoring ? null : detectUnrecognizedReviewHandoffCall(trimmed);
     const withSignal = (event) => {
-        if (!seekMentoring && !fraimJob && !usage && !agentIdentity)
+        if (!seekMentoring && !fraimJob && !usage && !agentIdentity && !unrecognizedReviewHandoffError)
             return event;
         return {
             ...event,
@@ -1543,6 +1631,7 @@ function parseHostLine(hostId, line) {
             ...(fraimJob ? { fraimJob } : {}),
             ...(usage ? { usage } : {}),
             ...(agentIdentity ? { agentIdentity } : {}),
+            ...(unrecognizedReviewHandoffError && !event.hostError ? { hostError: unrecognizedReviewHandoffError } : {}),
         };
     };
     if (hostId === 'codex') {
@@ -1655,7 +1744,7 @@ function parseHostLine(hostId, line) {
                     source: hostId,
                     backgroundTasks: parsed.tasks
                         .filter((t) => typeof t.task_id === 'string')
-                        .map((t) => ({ taskId: t.task_id, description: t.description })),
+                        .map((t) => ({ taskId: t.task_id, description: t.description, taskType: t.task_type })),
                 },
             });
         }
@@ -2209,6 +2298,17 @@ class ScriptedHostRuntime {
             agentIdentity: { agentName, agentModel },
         }, 'stdout');
     }
+    // Test API — feed a raw stdout line through the REAL parseHostLine parser
+    // instead of a hand-built ParsedHostEvent. Issue #1264: lets a test prove
+    // the actual tool-call-name recognition (not just the projection logic)
+    // handles a given raw shape, e.g. a flattened-lowercase tool name.
+    emitRawLine(runId, hostId, line) {
+        const target = this.resolveSession(runId);
+        if (!target)
+            return;
+        const parsed = parseHostLine(hostId, line);
+        target.handlers.onEvent({ ...parsed, sessionId: target.sessionId }, '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);