clementine-agent 1.18.209 → 1.18.210

package/dist/agent/agent-definitions.js

@@ -141,15 +141,15 @@ function buildHiredAgentDescription(p) {
         'Spawn this subagent when the user names them, asks a question in their domain, or asks Clementine to "have <name> do X".',
     ].filter(Boolean).join(' ');
 }
-/** Map a hired-agent profile to an AgentDefinition.
- *  Used when Clementine wants to delegate to Ross/Sasha/Nora etc. */
+/** Map a hired-agent profile to an AgentDefinition. */
 function profileToAgentDefinition(p) {
-    // Always include `Agent` so the subagent can further fan out, plus
-    // core read tools as a baseline. profile.team.allowedTools narrows
-    // beyond this when set.
-    const baseline = ['Agent', 'Read', 'Grep', 'Glob', 'WebSearch', 'WebFetch', 'TodoWrite'];
+    // Hired-agent definitions are leaf subagents by default. The Claude
+    // Agent SDK does not support recursive subagent spawning via `Agent`
+    // inside subagent tool lists; if Clementine grows nested orchestration,
+    // it should be explicit and depth-limited rather than accidental.
+    const baseline = ['Read', 'Grep', 'Glob', 'WebSearch', 'WebFetch', 'TodoWrite'];
     const tools = p.team?.allowedTools?.length
-        ? Array.from(new Set(['Agent', ...p.team.allowedTools]))
+        ? Array.from(new Set(p.team.allowedTools.filter(tool => tool !== 'Agent')))
         : baseline;
     return {
         description: buildHiredAgentDescription(p),
@@ -198,10 +198,10 @@ export function buildAgentMap(opts = {}) {
     // 1.18.198 — NO `tools` allowlist. Researcher inherits every tool the
     // parent has access to (Bash, Read, MCP wildcards, etc.). The earlier
     // hardcoded ['Read', 'Grep', 'Glob', 'WebSearch', 'WebFetch'] blocked
-    // researcher from using the parent's MCP servers — when Ross dispatched
-    // "Parallel SEO enrichment for 13 domains" the subagent couldn't call
+    // researcher from using the parent's MCP servers. A delegated
+    // "Parallel SEO enrichment for 13 domains" subagent couldn't call
     // `mcp__dataforseo__*` because it wasn't in the allowlist. Result: the
-    // subagent said "I can't do that" and Ross fell back to running 25
+    // subagent said "I can't do that" and the parent fell back to running 25
     // sequential MCP calls in his own turn, defeating the fan-out.
     //
     // Read-only behavior is enforced in RESEARCHER_PROMPT (behavior class:

package/dist/agent/approval-signals.d.ts

@@ -13,7 +13,7 @@
  *   ## Owner approval signals (recent)
  *   APPROVED (do more like this):
  *   - cron/insight-check: "Apply lean mode to reduce prompt size"
- *   - agent/sasha-the-cmo: "Add explicit citation requirement to system prompt"
+ *   - agent/marketing-agent: "Add explicit citation requirement to system prompt"
  *
  *   DENIED (avoid these patterns):
  *   - workflow/email-gen: "Replace template with LLM generation"  ← user note: "too generic; loses voice"
@@ -31,7 +31,7 @@ export interface ApprovalSignal {
     experimentId: string;
     /** The area the proposal targeted (cron, agent, skill, soul, etc.). */
     area: string;
-    /** The specific target (e.g., "insight-check", "sasha-the-cmo"). */
+    /** The specific target (e.g., "insight-check", "marketing-agent"). */
     target: string;
     /** The proposal's one-sentence hypothesis (truncated to 200 chars). */
     hypothesis: string;

package/dist/agent/approval-signals.js

@@ -13,7 +13,7 @@
  *   ## Owner approval signals (recent)
  *   APPROVED (do more like this):
  *   - cron/insight-check: "Apply lean mode to reduce prompt size"
- *   - agent/sasha-the-cmo: "Add explicit citation requirement to system prompt"
+ *   - agent/marketing-agent: "Add explicit citation requirement to system prompt"
  *
  *   DENIED (avoid these patterns):
  *   - workflow/email-gen: "Replace template with LLM generation"  ← user note: "too generic; loses voice"

package/dist/agent/assistant.js

@@ -262,6 +262,9 @@ const TOOLS_SERVER = `${ASSISTANT_NAME.toLowerCase()}-tools`;
 function mcpTool(name) {
     return `mcp__${TOOLS_SERVER}__${name}`;
 }
+function mcpServerWildcard(serverName) {
+    return `mcp__${serverName}__*`;
+}
 const CLEMENTINE_CORE_TOOL_NAMES = [
     'working_memory',
     'user_model',
@@ -1748,6 +1751,31 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                 fullSurface: false,
             };
         }
+        const profileComposioAllowList = profile?.allowedComposioToolkits;
+        if (!toolsDisabledForCall
+            && !isPlanStep
+            && !toolRoute.fullSurface
+            && Array.isArray(toolRoute.composioToolkits)
+            && !Array.isArray(profileComposioAllowList)) {
+            try {
+                const { listConnectedToolkits, matchConnectedToolkitsInText } = await import('../integrations/composio/client.js');
+                const composioRoutingText = [
+                    directScopeText,
+                    allowContextToolRoute ? contextRoutingText : '',
+                ].filter(Boolean).join('\n');
+                const mentioned = matchConnectedToolkitsInText(composioRoutingText, await listConnectedToolkits());
+                if (mentioned.length > 0) {
+                    toolRoute = {
+                        ...toolRoute,
+                        composioToolkits: [...new Set([...toolRoute.composioToolkits, ...mentioned])],
+                        reason: 'matched',
+                    };
+                }
+            }
+            catch (err) {
+                logger.debug({ err }, 'Connected Composio toolkit text match failed (non-fatal)');
+            }
+        }
         let allowedTools = [];
         const addAllowed = (...tools) => {
             for (const tool of tools) {
@@ -1944,9 +1972,8 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         if (!toolsDisabledForCall && !isPlanStep) {
             try {
                 const { buildComposioMcpServers } = await import('../integrations/composio/mcp-bridge.js');
-                const profileAllowList = profile?.allowedComposioToolkits;
-                const allowList = Array.isArray(profileAllowList)
-                    ? profileAllowList
+                const allowList = Array.isArray(profileComposioAllowList)
+                    ? profileComposioAllowList
                     : toolRoute.composioToolkits;
                 composioMcpServers = await buildComposioMcpServers(allowList);
             }
@@ -1956,6 +1983,10 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             }
         }
         const composioConnectedSlugs = Object.keys(composioMcpServers);
+        if (!toolsDisabledForCall) {
+            for (const slug of composioConnectedSlugs)
+                addAllowed(mcpServerWildcard(slug));
+        }
         const { stable, volatile: volatilePromptPart } = this.buildSystemPrompt({
             isHeartbeat, cronTier: isPlanStep ? null : cronTier, retrievalContext, profile, sessionKey, model: resolvedModel, verboseLevel, intentClassification,
             contextTier: turnPolicy?.retrievalTier ?? (retrievalContext ? 'full' : 'core'),

package/dist/agent/bg-planner.d.ts

@@ -4,7 +4,7 @@
  *
  * Why this exists (1.18.190)
  * ──────────────────────────
- * Before this, a complex multi-step user ask ("find the coaches project,
+ * Before this, a complex multi-step user ask ("find the catalog project,
  * build me an HTML report, deploy it to Netlify, verify the URL") got
  * handed to a single monolithic bg-task worker. The worker had its own
  * 200K context but still autocompact-thrashed because:
@@ -36,15 +36,14 @@
  * a multi-domain ask into proper steps is not mechanical.
  *
  * If you're tempted to "save tokens" by flipping this to Haiku, read
- * the 2026-05-12 root-cause plan first
- * (~/.claude/plans/look-at-the-last-vivid-rossum.md). The whole point
+ * a recent root-cause plan first. The whole point
  * of this ship is to NOT cut corners on the decomposition layer.
  */
 import type { ProjectMeta } from './assistant.js';
 export interface PlanStep {
     /** 0-indexed position. */
     index: number;
-    /** Short imperative title (e.g., "Find the coaches project"). */
+    /** Short imperative title (e.g., "Find the catalog project"). */
     title: string;
     /** What this step does, in 1-2 sentences. The chained worker sees this. */
     scope: string;

package/dist/agent/bg-planner.js

@@ -4,7 +4,7 @@
  *
  * Why this exists (1.18.190)
  * ──────────────────────────
- * Before this, a complex multi-step user ask ("find the coaches project,
+ * Before this, a complex multi-step user ask ("find the catalog project,
  * build me an HTML report, deploy it to Netlify, verify the URL") got
  * handed to a single monolithic bg-task worker. The worker had its own
  * 200K context but still autocompact-thrashed because:
@@ -36,8 +36,7 @@
  * a multi-domain ask into proper steps is not mechanical.
  *
  * If you're tempted to "save tokens" by flipping this to Haiku, read
- * the 2026-05-12 root-cause plan first
- * (~/.claude/plans/look-at-the-last-vivid-rossum.md). The whole point
+ * a recent root-cause plan first. The whole point
  * of this ship is to NOT cut corners on the decomposition layer.
  */
 import fs from 'node:fs';
@@ -202,7 +201,7 @@ function buildPlannerSystemPrompt() {
         '{',
         '  "steps": [',
         '    {',
-        '      "title": "<short imperative title, e.g. \'Find the coaches project\'>",',
+        '      "title": "<short imperative title, e.g. \'Find the catalog project\'>",',
         '      "scope": "<1-2 sentences describing exactly what this step does>",',
         '      "expectedTools": ["tool_name_1", "tool_name_2"],',
         '      "deliverable": "<file path | URL | description of the artifact>"',
@@ -273,7 +272,7 @@ async function runPlannerLlm(userPrompt, systemPrompt, model) {
     // Raw `systemPrompt: string` tells the SDK to use API-key auth, which
     // 99% of installs don't have configured — they're logged into Claude
     // Code, not the Anthropic API. This was the "Not logged in · Please
-    // run /login" failure Ross's owner hit on 2026-05-12.
+    // run /login" provider-auth failure.
     //
     // The preset injects Claude Code's default system prompt; our planning
     // instructions go in `append` and dominate behavior for the single

package/dist/agent/claim-verification.d.ts

@@ -5,7 +5,7 @@
  * Why this exists (1.18.187)
  * ──────────────────────────
  * On 2026-05-11 a bg task was diagnosed where Clementine said "The
- * site is live again at https://X.netlify.app — all 100 coaches with
+ * site is live again at https://X.netlify.app — all 100 product records with
  * search/filter/sort intact" — but the live URL returned HTTP 404,
  * and the run had zero tool calls matching a deploy. She had
  * confabulated success from a recall summary of a PRIOR task.

package/dist/agent/claim-verification.js

@@ -5,7 +5,7 @@
  * Why this exists (1.18.187)
  * ──────────────────────────
  * On 2026-05-11 a bg task was diagnosed where Clementine said "The
- * site is live again at https://X.netlify.app — all 100 coaches with
+ * site is live again at https://X.netlify.app — all 100 product records with
  * search/filter/sort intact" — but the live URL returned HTTP 404,
  * and the run had zero tool calls matching a deploy. She had
  * confabulated success from a recall summary of a PRIOR task.

package/dist/agent/clarification-gate.d.ts

@@ -0,0 +1,67 @@
+import type { RunSummary, SideEffectCall } from './run-summary.js';
+export type PendingAgentDecisionKind = 'blocked_external_action';
+export type BlockedActionCategory = 'deployment_target_missing';
+export interface PendingAgentDecision {
+    id: string;
+    kind: PendingAgentDecisionKind;
+    createdAt: number;
+    expiresAt: number;
+    runIds: string[];
+    originalRequest: string;
+    question: string;
+    context: {
+        category: BlockedActionCategory;
+        classifierId: string;
+        provider: string;
+        providerLabel: string;
+        blockerSummary: string;
+        failedCommand: string;
+        error: string;
+        targetNoun: string;
+        targetPlaceholder: string;
+        createInstructions: string[];
+        existingInstructions: string[];
+        projectPath?: string;
+        agentId?: string;
+        completedSideEffects?: string[];
+    };
+}
+export type AgentDecisionReply = {
+    kind: 'answer';
+    action: 'create_new_target';
+} | {
+    kind: 'answer';
+    action: 'use_existing_target';
+    target: string;
+} | {
+    kind: 'cancel';
+} | {
+    kind: 'unclear';
+    message: string;
+};
+export interface BlockedActionClassifier {
+    id: string;
+    category: BlockedActionCategory;
+    provider: string;
+    providerLabel: string;
+    targetNoun: string;
+    targetPlaceholder: string;
+    defaultCommand: string;
+    defaultError: string;
+    blockerSummary: string;
+    matches(call: SideEffectCall): boolean;
+    createInstructions: string[];
+    existingInstructions: string[];
+}
+/**
+ * Extension point for install-specific tool/provider blockers. Core owns the
+ * state machine; providers own only small classifiers and resume instructions.
+ */
+export declare function registerBlockedActionClassifier(classifier: BlockedActionClassifier): () => void;
+export declare function buildBlockedActionDecisionFromRunSummary(summary: RunSummary, originalRequest: string, nowMs?: number): PendingAgentDecision | null;
+export declare function parseAgentDecisionReply(decision: PendingAgentDecision, message: string): AgentDecisionReply;
+export declare function buildAgentDecisionContinuationPrompt(decision: PendingAgentDecision, reply: Extract<AgentDecisionReply, {
+    kind: 'answer';
+}>): string;
+export declare const buildRepairDecisionFromRunSummary: typeof buildBlockedActionDecisionFromRunSummary;
+//# sourceMappingURL=clarification-gate.d.ts.map

package/dist/agent/clarification-gate.js

@@ -0,0 +1,271 @@
+const customClassifiers = [];
+/**
+ * Extension point for install-specific tool/provider blockers. Core owns the
+ * state machine; providers own only small classifiers and resume instructions.
+ */
+export function registerBlockedActionClassifier(classifier) {
+    customClassifiers.unshift(classifier);
+    return () => {
+        const index = customClassifiers.indexOf(classifier);
+        if (index >= 0)
+            customClassifiers.splice(index, 1);
+    };
+}
+function firstString(...values) {
+    for (const value of values) {
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    return undefined;
+}
+function extractBashCommand(call) {
+    return firstString(call.input.command);
+}
+function sideEffectErrorText(call) {
+    return [
+        call.result?.error,
+        typeof call.result?.raw === 'string' ? call.result.raw : '',
+    ].filter(Boolean).join('\n');
+}
+function compactCommand(command) {
+    return command.replace(/\s+/g, ' ').trim().slice(0, 260);
+}
+function compactValue(value, max = 220) {
+    const compacted = value.replace(/\s+/g, ' ').trim();
+    return compacted.length > max ? `${compacted.slice(0, max - 3)}...` : compacted;
+}
+function extractProjectPathFromCommand(command) {
+    return command.match(/\bcd\s+"([^"]+)"/)?.[1]
+        ?? command.match(/\bcd\s+'([^']+)'/)?.[1]
+        ?? command.match(/\bcd\s+([^&;|]+)/)?.[1]?.trim();
+}
+function extractFilePathFromCall(call) {
+    const fromInput = firstString(call.input.file_path, call.input.filePath, call.input.path, call.input.target_path, call.input.targetPath);
+    if (fromInput)
+        return fromInput;
+    const raw = call.result?.raw;
+    if (typeof raw === 'string') {
+        return raw.match(/\b(?:File (?:created|updated) successfully at|file state is current in your context):\s*([^\n(]+)/i)?.[1]?.trim();
+    }
+    return undefined;
+}
+function summarizeCompletedSideEffect(call) {
+    if (call.toolName === 'Bash') {
+        const command = extractBashCommand(call);
+        return command ? `Bash command completed: ${compactCommand(command)}` : 'Bash command completed';
+    }
+    const filePath = extractFilePathFromCall(call);
+    if (filePath)
+        return `${call.toolName} completed for file: ${filePath}`;
+    return `${call.toolName} completed`;
+}
+function collectText(value) {
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value))
+        return value.map(collectText).filter(Boolean).join('\n');
+    if (!value || typeof value !== 'object')
+        return '';
+    const obj = value;
+    return ['text', 'content', 'result', 'message']
+        .map((key) => collectText(obj[key]))
+        .filter(Boolean)
+        .join('\n');
+}
+function extractAgentId(summary) {
+    for (const call of summary.successfulDelegations) {
+        const text = call.result ? collectText(call.result.raw) : '';
+        const match = text.match(/\bagentId:\s*([a-zA-Z0-9_-]+)/);
+        if (match?.[1])
+            return match[1];
+    }
+    return undefined;
+}
+const BUILTIN_CLASSIFIERS = [
+    {
+        id: 'netlify_missing_deployment_target',
+        category: 'deployment_target_missing',
+        provider: 'netlify',
+        providerLabel: 'Netlify',
+        targetNoun: 'deployment target',
+        targetPlaceholder: 'target-slug-or-id',
+        defaultCommand: 'netlify deploy',
+        defaultError: 'Deployment target is not linked',
+        blockerSummary: 'The deployment provider reported that this project is not linked to a deployment target.',
+        matches(call) {
+            if (call.toolName !== 'Bash')
+                return false;
+            const command = extractBashCommand(call) ?? '';
+            const error = sideEffectErrorText(call);
+            return /\bnetlify\s+deploy\b/i.test(command)
+                && /\bProject not found\. Please rerun "netlify link"|\bnetlify link\b/i.test(error);
+        },
+        createInstructions: [
+            'Create or link a new deployment target for this project, then deploy and verify the live URL.',
+            'Do not restart project discovery or reread full generated artifacts unless a small targeted read is necessary.',
+            'If provider auth, browser login, or an interactive naming choice is required and cannot be completed safely, stop and ask one concrete question.',
+            'If a Clementine deploy config is appropriate, write `.clementine/deploy.json` with the provider kind, target identifier, deploy directory, and verify URL.',
+            'Prefer `project_deploy` once deploy config exists; otherwise run the equivalent provider deploy command and verify the live URL before claiming success.',
+        ],
+        existingInstructions: [
+            'Use or link the existing deployment target: {target}',
+            'Do not restart project discovery or reread full generated artifacts unless a small targeted read is necessary.',
+            'Write or update `.clementine/deploy.json` for the existing target before deploying when that config is supported.',
+            'Prefer `project_deploy` once deploy config exists; otherwise run the equivalent provider deploy command and verify the live URL before claiming success.',
+            'If the provider rejects the target or auth is missing, stop and ask one concrete question with the exact CLI/API error.',
+        ],
+    },
+];
+function blockedActionClassifiers() {
+    return [...customClassifiers, ...BUILTIN_CLASSIFIERS];
+}
+function makeDecisionId(kind) {
+    return `${kind}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function formatDecisionPrompt(decision) {
+    return [
+        'I need one decision before I can continue this external action.',
+        '',
+        decision.context.blockerSummary,
+        `- Provider: ${decision.context.providerLabel}`,
+        `- Failed command: \`${decision.context.failedCommand}\``,
+        `- Provider said: ${decision.context.error}`,
+        ...(decision.context.projectPath ? [`- Project folder: \`${decision.context.projectPath}\``] : []),
+        ...(decision.context.agentId ? [`- Discovery already completed: agentId \`${decision.context.agentId}\``] : []),
+        '',
+        'Reply with one of these:',
+        `- \`create target\` to create/link a new ${decision.context.targetNoun}, deploy, and verify the result.`,
+        `- \`use existing <${decision.context.targetPlaceholder}>\` to use a target you already have.`,
+        '- `done` to stop here.',
+    ].join('\n');
+}
+export function buildBlockedActionDecisionFromRunSummary(summary, originalRequest, nowMs = Date.now()) {
+    for (const failedCall of summary.failedSideEffects) {
+        const classifier = blockedActionClassifiers().find(c => c.matches(failedCall));
+        if (!classifier)
+            continue;
+        const rawCommand = extractBashCommand(failedCall) ?? classifier.defaultCommand;
+        const failedCommand = compactCommand(rawCommand);
+        const error = sideEffectErrorText(failedCall).trim() || classifier.defaultError;
+        const projectPath = extractProjectPathFromCommand(rawCommand);
+        const agentId = extractAgentId(summary);
+        const completedSideEffects = summary.successfulSideEffects
+            .map(summarizeCompletedSideEffect)
+            .map((line) => compactValue(line))
+            .slice(0, 5);
+        const decision = {
+            id: makeDecisionId('blocked_external_action'),
+            kind: 'blocked_external_action',
+            createdAt: nowMs,
+            expiresAt: nowMs + 30 * 60_000,
+            runIds: summary.runIds,
+            originalRequest,
+            question: '',
+            context: {
+                category: classifier.category,
+                classifierId: classifier.id,
+                provider: classifier.provider,
+                providerLabel: classifier.providerLabel,
+                blockerSummary: classifier.blockerSummary,
+                failedCommand,
+                error: compactValue(error, 500),
+                targetNoun: classifier.targetNoun,
+                targetPlaceholder: classifier.targetPlaceholder,
+                createInstructions: classifier.createInstructions,
+                existingInstructions: classifier.existingInstructions,
+                ...(projectPath ? { projectPath } : {}),
+                ...(agentId ? { agentId } : {}),
+                ...(completedSideEffects.length > 0 ? { completedSideEffects } : {}),
+            },
+        };
+        decision.question = formatDecisionPrompt(decision);
+        return decision;
+    }
+    return null;
+}
+function unclearDecisionMessage(decision) {
+    return `I need a specific decision: reply \`create target\`, \`use existing <${decision.context.targetPlaceholder}>\`, or \`done\`.`;
+}
+export function parseAgentDecisionReply(decision, message) {
+    const text = message.trim();
+    const lower = text.toLowerCase().replace(/[.!?]+$/g, '').replace(/\s+/g, ' ').trim();
+    const intent = lower
+        .replace(/^(?:please|yes|yep|yeah|sure|ok|okay|go ahead(?: and)?)\s+/, '')
+        .replace(/\s+please$/, '')
+        .trim();
+    if (!lower) {
+        return {
+            kind: 'unclear',
+            message: unclearDecisionMessage(decision),
+        };
+    }
+    if (/^(?:done|stop|cancel|abort|no|nope|that's all|that is all|leave it)\b/.test(lower)) {
+        return { kind: 'cancel' };
+    }
+    if (/^(?:create|make|new)(?:\s+(?:(?:a|the)\s+)?(?:new\s+)?(?:target|deployment target|site|project|one))?$/.test(intent)
+        || /^(?:create|make)\s+(?:it|one)$/.test(intent)
+        || /\b(?:create|make)\s+(?:(?:a|the)\s+)?(?:new\s+)?(?:deployment\s+)?(?:target|site|project)\b/.test(intent)
+        || /\bnew\s+(?:deployment\s+)?(?:target|site|project)\b/.test(intent)) {
+        return { kind: 'answer', action: 'create_new_target' };
+    }
+    const explicitTarget = text.match(/^\s*(?:use|link)\s+(?:to\s+)?(?:the\s+)?(?:existing\s+)?(?:deployment\s+)?(?:target|site|project)\s+(.+?)\s*$/i)
+        ?? text.match(/^\s*(?:use|link)\s+(?:to\s+)?(?:existing\s+)?(.+?)\s*$/i)
+        ?? text.match(/^\s*target\s*:\s*(.+?)\s*$/i);
+    if (explicitTarget?.[1]) {
+        const target = explicitTarget[1].trim().replace(/^["'`]|["'`]$/g, '');
+        if (/[<>]/.test(target)) {
+            return {
+                kind: 'unclear',
+                message: `Please replace \`<${decision.context.targetPlaceholder}>\` with the actual ${decision.context.targetNoun} identifier or URL.`,
+            };
+        }
+        if (target)
+            return { kind: 'answer', action: 'use_existing_target', target };
+    }
+    const url = text.match(/https?:\/\/\S+/i);
+    if (url?.[0]) {
+        return { kind: 'answer', action: 'use_existing_target', target: url[0].replace(/[),.]+$/g, '') };
+    }
+    return {
+        kind: 'unclear',
+        message: unclearDecisionMessage(decision),
+    };
+}
+function renderInstructions(instructions, target) {
+    return instructions.map(line => target ? line.replace(/\{target\}/g, target) : line);
+}
+export function buildAgentDecisionContinuationPrompt(decision, reply) {
+    const lines = [
+        '[Agentic repair loop - read this before taking any action]',
+        'State transition: needs_user_decision -> executing',
+        `Decision kind: ${decision.kind}`,
+        `Blocker category: ${decision.context.category}`,
+        `Provider: ${decision.context.providerLabel}`,
+        `Previous run(s): ${decision.runIds.join(', ')}`,
+        '',
+        'Original owner request:',
+        decision.originalRequest,
+        '',
+        'Blocked step:',
+        `- Failed command: ${decision.context.failedCommand}`,
+        `- Error: ${decision.context.error}`,
+        ...(decision.context.projectPath ? [`- Project folder already identified: ${decision.context.projectPath}`] : []),
+        ...(decision.context.agentId ? [`- Discovery already completed by agentId ${decision.context.agentId}`] : []),
+        '',
+    ];
+    if (decision.context.completedSideEffects?.length) {
+        lines.push('Completed before the block. Do not repeat these unless verification proves they are stale:', ...decision.context.completedSideEffects.map((line) => `- ${line}`), '');
+    }
+    if (reply.action === 'create_new_target') {
+        lines.push('Owner decision:', `- Create/link a new ${decision.context.targetNoun}, then deploy and verify.`, '', 'Execution requirements:', ...renderInstructions(decision.context.createInstructions).map(line => `- ${line}`));
+    }
+    else {
+        lines.push('Owner decision:', `- Use existing ${decision.context.targetNoun}: ${reply.target}`, '', 'Execution requirements:', ...renderInstructions(decision.context.existingInstructions, reply.target).map(line => `- ${line}`));
+    }
+    lines.push('[/Agentic repair loop]');
+    return lines.join('\n');
+}
+// Backward-compatible alias for the router/tests while callers migrate to the
+// provider-neutral name.
+export const buildRepairDecisionFromRunSummary = buildBlockedActionDecisionFromRunSummary;
+//# sourceMappingURL=clarification-gate.js.map

package/dist/agent/clementine-turn-context.d.ts

@@ -57,7 +57,7 @@ export interface BuildTurnContextOptions {
      *  the identity framing block. */
     ownerName?: string | null;
     /** Active hired-agent profile if running as one. Affects the
-     *  identity framing — "you are talking to Sasha right now," not
+     *  identity framing — "you are talking to this hired agent right now," not
      *  "you are Clementine". */
     profileName?: string | null;
     /** Read-only memory store handle. When absent, retrieved-memory

package/dist/agent/clementine-turn-context.js

@@ -326,10 +326,14 @@ function buildActiveProjectBlock(project) {
             if (parsed && typeof parsed === 'object') {
                 const kind = parsed.kind ?? 'unknown';
                 const site = parsed.site ?? '?';
-                const dir = parsed.dir ?? 'output';
+                const command = typeof parsed.command === 'string' ? parsed.command.replace(/\s+/g, ' ').trim() : '';
+                const dir = parsed.dir ?? (kind === 'netlify' ? 'output' : '?');
                 const verifyUrl = parsed.verifyUrl ?? '?';
                 lines.push('');
-                lines.push(`**Deploy config:** ${kind} → ${site} (deploy dir: \`${dir}\`, verifies at ${verifyUrl}).`);
+                const target = command
+                    ? `command \`${command.slice(0, 160)}${command.length > 160 ? '...' : ''}\``
+                    : `target ${site}`;
+                lines.push(`**Deploy config:** ${kind} -> ${target} (deploy dir: \`${dir}\`, verifies at ${verifyUrl}).`);
                 lines.push('Use the \`project_deploy\` tool when ready — it runs the command AND curls the URL to verify before reporting success.');
             }
         }
@@ -338,7 +342,8 @@ function buildActiveProjectBlock(project) {
     else {
         lines.push('');
         lines.push('**No deploy config yet.** If this project should deploy somewhere, ask the owner where and ' +
-            'write `.clementine/deploy.json` with shape: `{kind: "netlify", site: "...", dir: "output", verifyUrl: "..."}`.');
+            'write `.clementine/deploy.json` with shape like `{kind: "custom", command: "npm run deploy", verifyUrl: "https://..."}`. ' +
+            'Provider adapters can add target fields such as `site` and `dir`.');
     }
     return lines.join('\n');
 }

package/dist/agent/complex-task-detector.d.ts

@@ -1,17 +1,12 @@
 /**
- * Explicit background-intent detector.
+ * Durable-work detector.
  *
- * Returns a recommendation ONLY when the user explicitly asks for background
- * / autonomous / overnight execution. We deliberately do not classify "this
- * looks complex" anymore — chat now stays in the live SDK loop, with
- * automatic compaction and inline subagent delegation (Agent → planner /
- * researcher / etc.) for context isolation, just like Claude Code itself.
- * Big work that genuinely blows past the SDK's auto-compact is caught by the
- * gateway's overflow → retry → promote-to-background fallback, which is the
- * *real* escape hatch instead of a regex pre-classifier.
- *
- * The narrow detection here is what lets a user say "go research this
- * overnight" and have it actually queue as a durable background task.
+ * Chat should stay live for normal multi-step work, but truly batch-heavy
+ * jobs should not require the owner to know the magic phrase "run this in the
+ * background." If the request clearly implies a long first pass — e.g. 100
+ * businesses, multiple external systems, research/enrichment plus sheet/email
+ * side effects — queue a durable background task immediately. Small project
+ * builds and single targeted actions still run in chat.
  */
 export interface ComplexTaskRecommendation {
     reasons: string[];