@borgee/agents-host 0.2.35 → 0.2.56

package/dist/context/prompt.js

@@ -1,8 +1,11 @@
+import { DEFAULT_PROJECTION_STRATEGY, normalizeProjectionStrategy, } from '../projection-strategy-values.js';
 import { AWAITING_USER_CONTROL_PREFIX } from '../providers/awaiting-user.js';
 import { buildAttentionSummaryLines } from './attention.js';
 import { buildCollaborationCapabilityDeclarationSummaryLines, buildMissedCollaborationDiagnosticSummaryLines, } from './collaboration-capabilities-diagnostics.js';
 import { buildCollaborationOutcomeSummaryLines } from './collaboration-outcome.js';
 import { MAIN_SESSION_DELEGATION_LINES } from './main-session-delegation.js';
+import { buildResolvedWorkspaceGuidanceLines } from './resolved-workspace.js';
+import { buildSkillManualLines, buildSkillManualReadLine } from './skill-manual.js';
 import { buildTaskThreadCollaborationSummaryLines } from './task-thread-collaboration.js';
 function providerLabel(provider) {
     if (provider === 'copilot') {
@@ -13,50 +16,61 @@ function providerLabel(provider) {
     }
     return 'Claude';
 }
-function buildSkillRuntimePromptLines(context) {
-    if (!context?.skillRuntime) {
+// Claude and Codex name the manual once on their session-scoped surfaces. Copilot has no
+// session-scoped surface — this prompt is its only model-facing text — so for Copilot alone the
+// pointer rides every turn.
+function buildSkillManualPromptLines(provider, context) {
+    if (provider !== 'copilot' || !context?.skillRuntime || !context.gatewayCredentialPath) {
         return [];
     }
-    return [
-        '',
-        'Read-only local skill runtime bootstrap is available for this turn.',
-        `Channel context payload: ${context.channelContextPayloadPath}`,
-        `Skill guide: ${context.skillRuntime.skillMarkdownPath}`,
-        `Node CLI: node ${context.skillRuntime.nodeCliPath} --context ${context.channelContextPayloadPath} --print-bootstrap`,
-        `Python CLI: python3 ${context.skillRuntime.pythonCliPath} --context ${context.channelContextPayloadPath} --print-bootstrap`,
-        'These CLIs are local-only, may only access the loopback gateway described below, must not mutate files or the local environment, and may only send auxiliary collaboration messages when that gateway surface is explicitly advertised below.',
-    ];
+    return ['', ...buildSkillManualLines(context.skillRuntime)];
 }
+// Only the facts that change from turn to turn: which credential file authorizes this turn, which
+// task grammar the thread shape licenses, and whether the collaboration commands can be reached at
+// all. Everything else a model needs to invoke the CLI is in the manual, which does not change.
 function buildLocalhostGatewayPromptLines(context) {
     if (!context?.localhostGateway) {
         return [];
     }
-    if (!context.gatewayAuthPath) {
+    if (!context.gatewayCredentialPath) {
         return [];
     }
-    const lines = [
-        '',
-        'A loopback-only localhost gateway is available for this turn.',
-        'Use the packaged local CLI with the existing --context payload to access the documented gateway surface.',
-        `Gateway auth sidecar for this turn: ${context.gatewayAuthPath}`,
-    ];
-    const isTaskAssignmentThread = context.taskAssignmentContext?.active === true;
+    const lines = ['', `Gateway credential file for this turn: ${context.gatewayCredentialPath}`];
     if (!context.skillRuntime) {
         return lines;
     }
-    lines.push('The read-only gateway commands listed in this prompt are already authorized for this turn and may be executed directly.', 'Do not ask the user for permission before using the read-only gateway commands listed below.', 'If the user asks about channel history, visible participants, or your current agent identity, run the relevant read command first and answer from its result instead of speculating about authorization.', `Node gateway checks: node ${context.skillRuntime.nodeCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --health`, `Node channel bootstrap: node ${context.skillRuntime.nodeCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --read-bootstrap`, `Node agent identity: node ${context.skillRuntime.nodeCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --get-me`, `Node channel history: node ${context.skillRuntime.nodeCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --read-history --limit 20`, `Python gateway checks: python3 ${context.skillRuntime.pythonCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --health`, `Python channel bootstrap: python3 ${context.skillRuntime.pythonCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --read-bootstrap`, `Python agent identity: python3 ${context.skillRuntime.pythonCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --get-me`, `Python channel history: python3 ${context.skillRuntime.pythonCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --read-history --limit 20`);
-    if (isTaskAssignmentThread) {
-        lines.push('Task-collection commands remain disabled inside this task thread; use the parent channel for create/list task operations.', `Node get current thread task: node ${context.skillRuntime.nodeCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --get-task`, `Node update current thread task: node ${context.skillRuntime.nodeCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --update-task [--status "<status>"] [--assignee-id "<assignee-id>"] [--title "<title>"]`, `Python get current thread task: python3 ${context.skillRuntime.pythonCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --get-task`, `Python update current thread task: python3 ${context.skillRuntime.pythonCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --update-task [--status "<status>"] [--assignee-id "<assignee-id>"] [--title "<title>"]`, `Node set current thread task property: node ${context.skillRuntime.nodeCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --set-property "<key>=<value>"`, `Node delete current thread task property: node ${context.skillRuntime.nodeCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --delete-property "<key>"`, `Python set current thread task property: python3 ${context.skillRuntime.pythonCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --set-property "<key>=<value>"`, `Python delete current thread task property: python3 ${context.skillRuntime.pythonCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --delete-property "<key>"`, 'Task property keys are a closed set: link.pr (the PR implementing the task) and link.issue (the originating issue). agent.session_id is written by agents-host — do not set it. One key per call; pass <key>=<value> as one argument.');
+    lines.push(context.taskAssignmentContext?.active === true
+        ? 'This turn runs inside a task assignment thread.'
+        : 'This turn runs in a parent channel, not a task thread.');
+    if (context.runtimeSurface?.task.currentThread === 'parent-channel'
+        && (context.collaborationTurnMode ?? 'ordinary') === 'ordinary') {
+        if (context.runtimeSurface.task.parentChannelTaskCollection === 'available') {
+            lines.push('Task list and task create are available in this parent channel.');
+            lines.push(`For parent-channel task operations on this turn, read the packaged borgee-agent manual at ${context.skillRuntime.skillMarkdownPath} and follow that command grammar exactly.`);
+            lines.push('For task creation and task updates in this parent channel, use the packaged borgee-agent task rail through this gateway credential file.');
+            lines.push('Do not invent a bare task or bare borgee command.');
+        }
+        if (context.runtimeSurface.task.currentTaskShorthand === 'requires-task-id') {
+            lines.push('In this parent channel, task get, task update, task history, and task property commands require an explicit task id.');
+        }
+    }
+    else if (context.runtimeSurface?.task.currentThread === 'task-assignment-thread'
+        && (context.collaborationTurnMode ?? 'ordinary') === 'ordinary') {
+        lines.push('In this task thread, task list and task create stay on the parent channel.');
     }
-    else {
-        lines.push(`Node create task: node ${context.skillRuntime.nodeCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --create-task --title "<title>" [--description "<description>"] [--assignee-id "<assignee-id>"]`, `Node list tasks: node ${context.skillRuntime.nodeCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --list-tasks`, `Node get task: node ${context.skillRuntime.nodeCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --get-task --task-id "<task-id>"`, `Node read task thread history: node ${context.skillRuntime.nodeCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --read-task-history --task-id "<task-id>" --limit 20`, `Node update task: node ${context.skillRuntime.nodeCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --update-task --task-id "<task-id>" [--status "<status>"] [--assignee-id "<assignee-id>"] [--title "<title>"]`, `Python create task: python3 ${context.skillRuntime.pythonCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --create-task --title "<title>" [--description "<description>"] [--assignee-id "<assignee-id>"]`, `Python list tasks: python3 ${context.skillRuntime.pythonCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --list-tasks`, `Python get task: python3 ${context.skillRuntime.pythonCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --get-task --task-id "<task-id>"`, `Python read task thread history: python3 ${context.skillRuntime.pythonCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --read-task-history --task-id "<task-id>" --limit 20`, `Python update task: python3 ${context.skillRuntime.pythonCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --update-task --task-id "<task-id>" [--status "<status>"] [--assignee-id "<assignee-id>"] [--title "<title>"]`, `Node set task property: node ${context.skillRuntime.nodeCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --set-property "<key>=<value>" --task-id "<task-id>"`, `Node delete task property: node ${context.skillRuntime.nodeCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --delete-property "<key>" --task-id "<task-id>"`, `Python set task property: python3 ${context.skillRuntime.pythonCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --set-property "<key>=<value>" --task-id "<task-id>"`, `Python delete task property: python3 ${context.skillRuntime.pythonCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --delete-property "<key>" --task-id "<task-id>"`, 'Task property keys are a closed set: link.pr (the PR implementing the task) and link.issue (the originating issue). agent.session_id is written by agents-host — do not set it. One key per call; pass <key>=<value> as one argument.');
+    const collaborationLive = context.localhostGateway.collaboration?.enabled === true
+        && (context.collaborationTurnMode ?? 'ordinary') === 'ordinary';
+    if (!collaborationLive) {
+        lines.push('Auxiliary collaboration commands (users, draft, send, mention) are not available this turn.');
+    }
+    else if (context.collaborationTurnExecutionId) {
+        lines.push(`Pass --turn-execution-id ${context.collaborationTurnExecutionId} on send, mention and draft.`);
+    }
+    if (context.runtimeSurface?.response.mainVisibleReply === 'model-visible-reply') {
+        lines.push('Keep the main visible completion in this thread.');
     }
-    if (context.localhostGateway.collaboration?.enabled &&
-        (context.collaborationTurnMode ?? 'ordinary') === 'ordinary') {
-        const turnExecutionArgument = context.collaborationTurnExecutionId
-            ? ` --turn-execution-id ${context.collaborationTurnExecutionId}`
-            : '';
-        lines.push('Auxiliary collaboration commands are available for this turn. Use them only for short targeted escalation, mention, or reply notices, never for the main final answer body.', 'When you need the host-private in-flight draft for this live collaboration turn, use the dedicated read-draft command rather than inspecting public channel messages.', 'When --list-users is listed below, it is a read-only command for this turn and may be executed directly without asking for permission.', 'When the user explicitly asks you to mention, ping, notify, or send a short note to another visible participant, use the dedicated send-mention command directly and include a visible <@targetId> token in the body.', 'If the user asks you to @ another agent now, send the short auxiliary mention first, then confirm what you sent.', 'If the user says "the other agent" and only one other visible agent is present, resolve that target from --list-users and then use --send-mention with that participant id.', 'If collaboration with another visible agent would help, use these auxiliary commands to send a short targeted mention or reply-thread note yourself rather than asking AgentsHost to orchestrate a special protocol.', `Node private draft snapshot: node ${context.skillRuntime.nodeCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath}${turnExecutionArgument} --read-draft`, `Node user directory: node ${context.skillRuntime.nodeCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --list-users`, `Node auxiliary mention: node ${context.skillRuntime.nodeCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath}${turnExecutionArgument} --send-mention user-id --body "Need review from <@user-id>"`, `Node reply thread notice: node ${context.skillRuntime.nodeCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath}${turnExecutionArgument} --send-message --body "Following up here" --reply-to message-id`, `Python private draft snapshot: python3 ${context.skillRuntime.pythonCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath}${turnExecutionArgument} --read-draft`, `Python user directory: python3 ${context.skillRuntime.pythonCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath} --list-users`, `Python auxiliary mention: python3 ${context.skillRuntime.pythonCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath}${turnExecutionArgument} --send-mention user-id --body "Need review from <@user-id>"`, `Python reply thread notice: python3 ${context.skillRuntime.pythonCliPath} --context ${context.channelContextPayloadPath} --auth-path ${context.gatewayAuthPath}${turnExecutionArgument} --send-message --body "Following up here" --reply-to message-id`);
+    if (context.runtimeSurface?.response.auxiliaryMessageUsage === 'targeted-escalation-only') {
+        lines.push('Use auxiliary sends only for intentional targeted escalation, mention, or reply notices when the injected runtimeSurface allows them.');
     }
     return lines;
 }
@@ -66,6 +80,12 @@ function buildTaskAssignmentPromptLines(params) {
     if (!isTaskAssignmentTurn && taskAssignmentContext?.active !== true) {
         return [];
     }
+    if (params.provider === 'claude'
+        && params.forceInlineForClaude !== true
+        && !isTaskAssignmentTurn
+        && taskAssignmentContext?.active === true) {
+        return [];
+    }
     const lines = isTaskAssignmentTurn
         ? [
             'This message is a task assignment.',
@@ -75,21 +95,167 @@ function buildTaskAssignmentPromptLines(params) {
             'This thread is continuing an existing task assignment.',
             'Keep the main work in this thread.',
         ];
-    if (taskAssignmentContext?.currentTaskId) {
+    if ((params.provider !== 'claude' || params.forceInlineForClaude === true) && params.promptContext?.resolvedWorkspace) {
+        lines.push(...buildResolvedWorkspacePromptLines(params.provider, params.promptContext));
+    }
+    if ((params.provider !== 'claude' || params.forceInlineForClaude === true) && taskAssignmentContext?.currentTaskId) {
         lines.push(`Current assigned task id: ${taskAssignmentContext.currentTaskId}.`);
-        lines.push('Inside this task thread, the packaged Node and Python CLIs may omit --task-id for --get-task and --update-task because the current task id is already persisted in the injected thread context.');
-        if (params.promptContext?.taskWorkspace) {
-            lines.push(`Task-scoped writable workspace root: ${params.promptContext.taskWorkspace.rootPath}.`);
-            lines.push('This writable workspace is local to agents-host for the current task thread. It does not imply that the target repository has already been checked out there.');
-        }
     }
-    else if (taskAssignmentContext?.active === true) {
+    else if ((params.provider !== 'claude' || params.forceInlineForClaude === true) && taskAssignmentContext?.active === true) {
         lines.push('No current task id is persisted in the injected thread context for this task thread.');
-        lines.push('Inside this task thread, shorthand --get-task/--update-task calls without --task-id use an agents-host local fallback that scans visible parent-channel tasks for this thread; pass --task-id explicitly if that fallback cannot resolve a unique task.');
     }
-    lines.push('Set the task status to in_progress when you start.', 'When you finish, set the task status to in_review and return your normal final response in this thread.', 'Do not use an auxiliary message command for the main completion report; reserve it for intentional targeted escalation or cross-channel notification.', 'Do not use create/list task operations inside this task thread; those remain parent-channel operations.', 'Do not move the main work back to the parent channel.');
+    if (params.provider !== 'claude' || params.forceInlineForClaude === true) {
+        lines.push('Return your normal final response in this thread, and do not move the main work back to the parent channel.');
+    }
+    return lines;
+}
+function buildResolvedWorkspacePromptLines(provider, context) {
+    return buildResolvedWorkspaceGuidanceLines(context, provider);
+}
+function buildClaudeOrdinaryGatewayTaskLines(context) {
+    if (!context?.skillRuntime || !context.localhostGateway || !context.gatewayCredentialPath) {
+        return [];
+    }
+    if ((context.collaborationTurnMode ?? 'ordinary') !== 'ordinary') {
+        return [];
+    }
+    if (context.runtimeSurface?.task.currentThread !== 'parent-channel') {
+        return [];
+    }
+    if (context.runtimeSurface.task.parentChannelTaskCollection !== 'available') {
+        return [];
+    }
+    const lines = [
+        `Gateway credential file for this turn: ${context.gatewayCredentialPath}`,
+        'This turn runs in a parent channel, not a task thread.',
+        'Task list and task create are available in this parent channel.',
+        `For parent-channel task operations on this turn, read the packaged borgee-agent manual at ${context.skillRuntime.skillMarkdownPath} and follow that command grammar exactly.`,
+        'For task creation and task updates in this parent channel, use the packaged borgee-agent task rail through this gateway credential file.',
+        'Do not invent a bare task or bare borgee command.',
+    ];
+    if (context.runtimeSurface.task.currentTaskShorthand === 'requires-task-id') {
+        lines.push('In this parent channel, task get, task update, task history, and task property commands require an explicit task id.');
+    }
     return lines;
 }
+function buildClaudeProjectedBriefSessionLines(context) {
+    if (!context?.claudeProjectedBriefPath) {
+        return [];
+    }
+    const lines = [
+        `Read the stable Borgee runtime brief for this session at ${context.claudeProjectedBriefPath} before you act on this channel; it is authoritative for the stable platform rules on this channel.`,
+    ];
+    if (context.skillRuntime) {
+        lines.push(`For command grammar and CLI inventory, read the packaged borgee-agent manual at ${context.skillRuntime.skillMarkdownPath}.`);
+    }
+    lines.push(...buildClaudeOrdinarySessionControlLines());
+    return lines;
+}
+function buildClaudeProjectedBriefTurnDeltaLines(context) {
+    if (!context?.localhostGateway || !context.gatewayCredentialPath) {
+        return [];
+    }
+    const lines = [];
+    if ((context.collaborationTurnMode ?? 'ordinary') !== 'ordinary') {
+        return [`Gateway credential file for this turn: ${context.gatewayCredentialPath}`];
+    }
+    if (context.runtimeSurface?.task.currentThread === 'parent-channel') {
+        const taskLines = buildClaudeOrdinaryGatewayTaskLines(context);
+        if (taskLines.length > 0) {
+            lines.push(...taskLines);
+        }
+        else {
+            lines.push(`Gateway credential file for this turn: ${context.gatewayCredentialPath}`, 'This turn runs in a parent channel, not a task thread.');
+            if (context.runtimeSurface.task.parentChannelTaskCollection === 'available') {
+                lines.push('Task list and task create are available in this parent channel.');
+            }
+        }
+    }
+    else if (context.runtimeSurface?.task.currentThread === 'task-assignment-thread') {
+        lines.push(`Gateway credential file for this turn: ${context.gatewayCredentialPath}`, 'This turn runs inside a task assignment thread.', 'In this task thread, task list and task create stay on the parent channel.');
+    }
+    else {
+        lines.push(`Gateway credential file for this turn: ${context.gatewayCredentialPath}`);
+    }
+    const collaborationLive = context.localhostGateway.collaboration?.enabled === true
+        && (context.collaborationTurnMode ?? 'ordinary') === 'ordinary';
+    if (!collaborationLive) {
+        lines.push('Auxiliary collaboration commands (users, draft, send, mention) are not available this turn.');
+    }
+    else if (context.collaborationTurnExecutionId) {
+        lines.push(`Pass --turn-execution-id ${context.collaborationTurnExecutionId} on send, mention and draft.`);
+    }
+    if (context.runtimeSurface?.response.mainVisibleReply === 'model-visible-reply') {
+        lines.push('Keep the main visible completion in this thread.');
+    }
+    if (context.runtimeSurface?.response.auxiliaryMessageUsage === 'targeted-escalation-only') {
+        lines.push('Use auxiliary sends only for intentional targeted escalation, mention, or reply notices when the injected runtimeSurface allows them.');
+    }
+    return lines;
+}
+function buildClaudeProjectedBriefTurnPrompt(params) {
+    if (isClaudeZeroTurnFallbackRequired(params)) {
+        return buildClaudeZeroTurnPrompt(params);
+    }
+    if (!params.promptContext?.claudeProjectedBriefPath) {
+        return [
+            ...buildClaudeTurnControlPromptLines(params.promptContext),
+            ...buildPromptBodyLines({
+                provider: 'claude',
+                channelId: params.channelId,
+                incomingAuthorId: params.incomingAuthorId,
+                incomingContent: params.incomingContent,
+                incomingEventKind: params.incomingEventKind,
+                incomingMessageType: params.incomingMessageType,
+                promptContext: params.promptContext,
+            }),
+        ].join('\n');
+    }
+    const deltaLines = buildClaudeProjectedBriefTurnDeltaLines(params.promptContext);
+    return [
+        ...buildClaudeTurnControlPromptLines(params.promptContext),
+        `Channel: ${params.channelId}`,
+        ...buildInboundMetadataLines({
+            provider: 'claude',
+            incomingEventKind: params.incomingEventKind,
+            incomingMessageType: params.incomingMessageType,
+            promptContext: params.promptContext,
+        }),
+        ...(() => {
+            const lines = buildCollaborationOutcomeSummaryLines(params.promptContext?.collaborationOutcome);
+            return lines.length > 0 ? ['', ...lines] : [];
+        })(),
+        ...(() => {
+            const lines = buildAttentionSummaryLines(params.promptContext?.attentionSnapshot);
+            return lines.length > 0 ? ['', ...lines] : [];
+        })(),
+        ...(() => {
+            const lines = buildCollaborationCapabilityDeclarationSummaryLines(params.promptContext?.collaborationCapabilities);
+            return lines.length > 0 ? ['', ...lines] : [];
+        })(),
+        ...(() => {
+            const lines = buildMissedCollaborationDiagnosticSummaryLines(params.promptContext?.missedCollaborationDiagnostic);
+            return lines.length > 0 ? ['', ...lines] : [];
+        })(),
+        ...(deltaLines.length > 0 ? ['', ...deltaLines] : []),
+        '',
+        `New message from ${params.incomingAuthorId}:`,
+        params.incomingContent,
+    ].join('\n');
+}
+function buildOrdinaryCopilotWorkspacePromptLines(params) {
+    if (params.provider !== 'copilot') {
+        return [];
+    }
+    if (!params.promptContext?.resolvedWorkspace) {
+        return [];
+    }
+    if (params.incomingMessageType?.trim() === 'task_assignment'
+        || params.promptContext.taskAssignmentContext?.active === true) {
+        return [];
+    }
+    return buildResolvedWorkspacePromptLines(params.provider, params.promptContext);
+}
 function buildInboundMetadataLines(params) {
     return [
         `Incoming transport event kind: ${params.incomingEventKind?.trim() || 'message'}`,
@@ -98,7 +264,16 @@ function buildInboundMetadataLines(params) {
             const lines = buildTaskThreadCollaborationSummaryLines(params.promptContext?.taskThreadCollaborationContract);
             return lines.length > 0 ? ['', ...lines] : [];
         })(),
-        ...buildTaskAssignmentPromptLines(params),
+        ...(() => {
+            const lines = buildOrdinaryCopilotWorkspacePromptLines(params);
+            return lines.length > 0 ? ['', ...lines] : [];
+        })(),
+        ...buildTaskAssignmentPromptLines({
+            provider: params.provider,
+            incomingMessageType: params.incomingMessageType,
+            promptContext: params.promptContext,
+            forceInlineForClaude: params.forceClaudeTaskAssignmentInline,
+        }),
     ];
 }
 function describeIdentity(identity) {
@@ -109,7 +284,7 @@ function describeIdentity(identity) {
     const label = name && name.length > 0 ? `${name} (${identity.id})` : identity.id;
     return `${label}, kind=${identity.kind}`;
 }
-function buildTurnControlPromptLines(context) {
+function buildTurnControlAttentionLines(context) {
     const taskThreadAttentionAvailable = context?.taskAssignmentContext?.active === true
         && typeof context.taskAssignmentContext.currentTaskId === 'string'
         && context.taskAssignmentContext.currentTaskId.trim().length > 0;
@@ -135,6 +310,10 @@ function buildTurnControlPromptLines(context) {
             `For an attention-only reply, keep a non-empty visible body and append: ${AWAITING_USER_CONTROL_PREFIX}{"kind":"attention-only","attentionUpdate":"follow-channel"}`,
         ]
         : [];
+    return { attentionLines, attentionOnlyLine };
+}
+function buildTurnControlPromptLines(context) {
+    const { attentionLines, attentionOnlyLine } = buildTurnControlAttentionLines(context);
     if (!context) {
         return [
             `Only when you need host-local turn control, append exactly one final non-empty line starting with ${AWAITING_USER_CONTROL_PREFIX}.`,
@@ -207,14 +386,69 @@ function buildTurnControlPromptLines(context) {
         'Do not emit multiple control lines, and do not use a control footer for ordinary answers.',
     ];
 }
-/**
- * Builds the per-turn prompt. Conversation memory is intentionally NOT
- * assembled here: each provider's CLI client resumes a native per-channel
- * session (Claude `--resume`, Copilot `--session-id`), so the CLI itself
- * already has the prior turns. This only needs to carry the agent's
- * identity/instructions plus the new incoming message.
- */
-export function buildPrompt(params) {
+function buildClaudeTurnControlPromptLines(context) {
+    const { attentionLines, attentionOnlyLine } = buildTurnControlAttentionLines(context);
+    if (context?.collaborationTurnMode === 'protocol-managed' && context.protocol) {
+        const selfIdentity = describeIdentity(context.grounding?.self);
+        const incomingIdentity = describeIdentity(context.grounding?.incomingAuthor);
+        const peerIdentity = describeIdentity(context.grounding?.peer);
+        return [
+            `Protocol-managed collaboration is already active for this turn. Your host-managed role is ${context.protocol.role}, and your target peer is ${context.protocol.targetPeerId}.`,
+            ...(selfIdentity ? [`Your self identity for this turn: ${selfIdentity}.`] : []),
+            ...(peerIdentity ? [`Your peer for this turn: ${peerIdentity}.`] : []),
+            ...(incomingIdentity ? [`The incoming author for this turn is ${incomingIdentity}.`] : []),
+            'The host will deliver the visible protocol reply body for you; you only decide the body plus exactly one control footer.',
+            'Do not use auxiliary collaboration send commands during this turn, even if other turns can use them.',
+            'Do not attempt a localhost gateway message post during this turn.',
+            `When handing off to the named peer, use: ${AWAITING_USER_CONTROL_PREFIX}{"kind":"continue-to-peer"}`,
+            `When finishing locally, use: ${AWAITING_USER_CONTROL_PREFIX}{"kind":"conclude-locally"}`,
+            `If you are blocked on the human instead, use: ${AWAITING_USER_CONTROL_PREFIX}{"kind":"awaiting-user","question":"<short question>","reason":"<short reason>"}`,
+            ...(context.attentionSnapshot
+                ? ['You may add one attentionUpdate field to continue-to-peer, conclude-locally, or awaiting-user when you also need an attention change for this channel.']
+                : []),
+            ...attentionLines,
+            'Do not use start-protocol while host-managed collaboration is already active.',
+        ];
+    }
+    if (context?.collaborationTurnMode === 'silent-kickoff' && context.kickoff) {
+        const kickoff = context.kickoff;
+        const otherParticipantId = kickoff.participantIds.find((participantId) => participantId !== kickoff.issuerId);
+        const selfIdentity = describeIdentity(context.grounding?.self);
+        const incomingIdentity = describeIdentity(context.grounding?.incomingAuthor);
+        const peerIdentity = describeIdentity(context.grounding?.peer);
+        const participantSummary = context.grounding?.participants
+            ?.map((participant) => describeIdentity(participant))
+            .filter((participant) => participant != null)
+            .join('; ');
+        return [
+            `Silent protocol kickoff evaluation is active for anchor ${kickoff.anchorMessageId}. The issuer is ${kickoff.issuerId}${otherParticipantId ? ` and the other participant is ${otherParticipantId}` : ''}.`,
+            ...(context.grounding?.hostRecognizedKickoffCandidate
+                ? [
+                    'The host has already recognized this message as a structurally valid kickoff candidate and is asking you to decide whether host-managed collaboration should start.',
+                ]
+                : []),
+            ...(selfIdentity ? [`Your self identity for this decision: ${selfIdentity}.`] : []),
+            ...(peerIdentity ? [`Your peer candidate for this decision: ${peerIdentity}.`] : []),
+            ...(incomingIdentity
+                ? [`The incoming author for this decision is ${incomingIdentity}.`]
+                : []),
+            ...(participantSummary ? [`Visible kickoff participants: ${participantSummary}.`] : []),
+            'This evaluation is read-only and silent: do not use auxiliary collaboration send commands, and do not draft a user-visible reply body for this turn.',
+            `If the anchor message is genuinely requesting host-managed collaboration between the named agents, use: ${AWAITING_USER_CONTROL_PREFIX}{"kind":"start-protocol","rounds":<positive integer>}`,
+            'Do not combine start-protocol with any attentionUpdate field.',
+            'If collaboration should not start, omit the control footer entirely.',
+        ];
+    }
+    return [
+        'Do not claim to have performed actions you did not actually perform.',
+        ...(context?.attentionSnapshot
+            ? ['You may add one attentionUpdate field to awaiting-user when you also need an attention change for this channel.']
+            : []),
+        ...attentionLines,
+        ...attentionOnlyLine,
+    ];
+}
+function buildPromptHeaderLines(params) {
     return [
         `You are ${params.agentName}, a helpful AI teammate inside Borgee.`,
         `Your current backend provider is ${providerLabel(params.provider)} (${params.provider}).`,
@@ -222,14 +456,34 @@ export function buildPrompt(params) {
         'Be concise, helpful, and honest about uncertainty.',
         'Do not claim to have performed actions you did not actually perform.',
         'Keep the visible reply text concise.',
-        ...MAIN_SESSION_DELEGATION_LINES,
-        ...buildTurnControlPromptLines(params.promptContext),
-        `If the user asks who you are, what powers you, or which backend/provider you use, mention that you are currently running on ${providerLabel(params.provider)}.`,
+    ];
+}
+function buildProviderIdentityReminderLine(provider) {
+    return `If the user asks who you are, what powers you, or which backend/provider you use, mention that you are currently running on ${providerLabel(provider)}.`;
+}
+function buildSessionDelegationPromptLines(provider, context) {
+    if (provider === 'copilot') {
+        return MAIN_SESSION_DELEGATION_LINES;
+    }
+    return context?.skillRuntime ? [] : MAIN_SESSION_DELEGATION_LINES;
+}
+function buildClaudeOrdinarySessionControlLines() {
+    return [
+        `Only when you need host-local turn control, append exactly one final non-empty line starting with ${AWAITING_USER_CONTROL_PREFIX}.`,
+        `For ordinary blocked-on-human turns, use: ${AWAITING_USER_CONTROL_PREFIX}{"kind":"awaiting-user","question":"<short question>","reason":"<short reason>"}`,
+        'Do not emit multiple control lines.',
+        'Do not use a control footer for ordinary answers.',
+    ];
+}
+function buildPromptBodyLines(params) {
+    return [
         `Channel: ${params.channelId}`,
         ...buildInboundMetadataLines({
+            provider: params.provider,
             incomingEventKind: params.incomingEventKind,
             incomingMessageType: params.incomingMessageType,
             promptContext: params.promptContext,
+            forceClaudeTaskAssignmentInline: params.forceClaudeTaskAssignmentInline,
         }),
         ...(() => {
             const lines = buildCollaborationOutcomeSummaryLines(params.promptContext?.collaborationOutcome);
@@ -247,10 +501,178 @@ export function buildPrompt(params) {
             const lines = buildMissedCollaborationDiagnosticSummaryLines(params.promptContext?.missedCollaborationDiagnostic);
             return lines.length > 0 ? ['', ...lines] : [];
         })(),
-        ...buildSkillRuntimePromptLines(params.promptContext),
+        ...buildSkillManualPromptLines(params.provider, params.promptContext),
         ...buildLocalhostGatewayPromptLines(params.promptContext),
         '',
         `New message from ${params.incomingAuthorId}:`,
         params.incomingContent,
+    ];
+}
+function resolveProjectionStrategy(strategy) {
+    return normalizeProjectionStrategy(strategy) ?? DEFAULT_PROJECTION_STRATEGY;
+}
+function isClaudeZeroTurnFallbackRequired(params) {
+    return (params.incomingMessageType?.trim() === 'task_assignment'
+        || params.promptContext?.collaborationTurnMode === 'protocol-managed'
+        || params.promptContext?.collaborationTurnMode === 'silent-kickoff');
+}
+function buildClaudeLegacyTurnPrompt(params) {
+    const controlLines = params.promptContext?.collaborationTurnMode
+        && params.promptContext.collaborationTurnMode !== 'ordinary'
+        ? buildClaudeTurnControlPromptLines(params.promptContext)
+        : buildTurnControlPromptLines(params.promptContext);
+    const environmentLines = buildClaudeSessionEnvironmentLines(params.promptContext);
+    const sessionDelegationLines = params.promptContext?.skillRuntime ? [] : MAIN_SESSION_DELEGATION_LINES;
+    return [
+        ...buildPromptHeaderLines({
+            agentName: params.agentName ?? 'Borgee agent',
+            provider: 'claude',
+        }),
+        ...sessionDelegationLines,
+        ...(environmentLines.length > 0 ? ['', ...environmentLines] : []),
+        ...controlLines,
+        buildProviderIdentityReminderLine('claude'),
+        ...buildPromptBodyLines({
+            provider: 'claude',
+            channelId: params.channelId,
+            incomingAuthorId: params.incomingAuthorId,
+            incomingContent: params.incomingContent,
+            incomingEventKind: params.incomingEventKind,
+            incomingMessageType: params.incomingMessageType,
+            promptContext: params.promptContext,
+            forceClaudeTaskAssignmentInline: true,
+        }),
+    ].join('\n');
+}
+function buildClaudeZeroTurnPrompt(params) {
+    if (isClaudeZeroTurnFallbackRequired(params)) {
+        return [
+            ...buildClaudeTurnControlPromptLines(params.promptContext),
+            ...buildPromptBodyLines({
+                provider: 'claude',
+                channelId: params.channelId,
+                incomingAuthorId: params.incomingAuthorId,
+                incomingContent: params.incomingContent,
+                incomingEventKind: params.incomingEventKind,
+                incomingMessageType: params.incomingMessageType,
+                promptContext: params.promptContext,
+            }),
+        ].join('\n');
+    }
+    const gatewayTaskLines = buildClaudeOrdinaryGatewayTaskLines(params.promptContext);
+    return [
+        'Do not claim to have performed actions you did not actually perform.',
+        ...(gatewayTaskLines.length > 0 ? [...gatewayTaskLines, ''] : []),
+        `New message from ${params.incomingAuthorId}:`,
+        params.incomingContent,
+    ].join('\n');
+}
+function buildClaudeMinimalTurnPrompt(params) {
+    if (isClaudeZeroTurnFallbackRequired(params)) {
+        return buildClaudeZeroTurnPrompt(params);
+    }
+    const gatewayTaskLines = buildClaudeOrdinaryGatewayTaskLines(params.promptContext);
+    return [
+        `You are ${params.agentName ?? 'Borgee agent'}, a helpful AI teammate inside Borgee.`,
+        'You are replying inside a shared collaboration channel.',
+        'Do not claim to have performed actions you did not actually perform.',
+        'Keep the visible reply text concise.',
+        ...(gatewayTaskLines.length > 0 ? ['', ...gatewayTaskLines] : []),
+        '',
+        `New message from ${params.incomingAuthorId}:`,
+        params.incomingContent,
+    ].join('\n');
+}
+function buildClaudeSessionEnvironmentLines(context) {
+    if (!context) {
+        return [];
+    }
+    const lines = [];
+    if (context.skillRuntime) {
+        lines.push(...(context.gatewayCredentialPath
+            ? buildSkillManualLines(context.skillRuntime)
+            : [buildSkillManualReadLine(context.skillRuntime)]));
+    }
+    if (context.localhostGateway && context.gatewayCredentialPath) {
+        lines.push(`Gateway credential file for this session: ${context.gatewayCredentialPath}`);
+    }
+    lines.push(...buildResolvedWorkspaceGuidanceLines(context));
+    if (context.taskAssignmentContext?.currentTaskId) {
+        lines.push(`Current assigned task id: ${context.taskAssignmentContext.currentTaskId}.`);
+    }
+    else if (context.taskAssignmentContext?.active === true) {
+        lines.push('No current task id is persisted in the injected thread context for this task thread.');
+    }
+    if (context.taskAssignmentContext?.active === true) {
+        lines.push('This session is an active task assignment thread. Keep the main work in this thread.', 'Return your normal final response in this thread, and do not move the main work back to the parent channel.');
+    }
+    return lines;
+}
+/**
+ * Builds the per-turn prompt. Conversation memory is intentionally NOT
+ * assembled here: each provider's CLI client resumes a native per-channel
+ * session (Claude `--resume`, Copilot `--session-id`), so the CLI itself
+ * already has the prior turns. This only needs to carry the agent's
+ * identity/instructions plus the new incoming message.
+ */
+export function buildPrompt(params) {
+    return [
+        ...buildPromptHeaderLines(params),
+        ...buildSessionDelegationPromptLines(params.provider, params.promptContext),
+        ...buildTurnControlPromptLines(params.promptContext),
+        buildProviderIdentityReminderLine(params.provider),
+        ...buildPromptBodyLines(params),
+    ].join('\n');
+}
+export function buildClaudeSessionPromptAppend(params) {
+    const promptStrategy = resolveProjectionStrategy(params.promptStrategy);
+    if (promptStrategy === 'turn-full') {
+        return undefined;
+    }
+    if (promptStrategy === 'file-brief' && params.promptContext?.claudeProjectedBriefPath) {
+        const bootstrapLines = buildClaudeProjectedBriefSessionLines(params.promptContext);
+        return [
+            ...buildPromptHeaderLines({ agentName: params.agentName, provider: 'claude' }),
+            ...(bootstrapLines.length > 0 ? ['', ...bootstrapLines] : []),
+            '',
+            buildProviderIdentityReminderLine('claude'),
+        ].join('\n');
+    }
+    const environmentLines = buildClaudeSessionEnvironmentLines(params.promptContext);
+    const sessionDelegationLines = params.promptContext?.skillRuntime ? [] : MAIN_SESSION_DELEGATION_LINES;
+    return [
+        ...buildPromptHeaderLines({ agentName: params.agentName, provider: 'claude' }),
+        ...sessionDelegationLines,
+        ...(environmentLines.length > 0 ? ['', ...environmentLines] : []),
+        '',
+        ...buildClaudeOrdinarySessionControlLines(),
+        buildProviderIdentityReminderLine('claude'),
+    ].join('\n');
+}
+export function buildClaudeTurnPrompt(params) {
+    const promptStrategy = resolveProjectionStrategy(params.promptStrategy);
+    if (promptStrategy === 'turn-full') {
+        return buildClaudeLegacyTurnPrompt(params);
+    }
+    if (promptStrategy === 'message-only') {
+        return buildClaudeZeroTurnPrompt(params);
+    }
+    if (promptStrategy === 'turn-thin') {
+        return buildClaudeMinimalTurnPrompt(params);
+    }
+    if (promptStrategy === 'file-brief') {
+        return buildClaudeProjectedBriefTurnPrompt(params);
+    }
+    return [
+        ...buildClaudeTurnControlPromptLines(params.promptContext),
+        ...buildPromptBodyLines({
+            provider: 'claude',
+            channelId: params.channelId,
+            incomingAuthorId: params.incomingAuthorId,
+            incomingContent: params.incomingContent,
+            incomingEventKind: params.incomingEventKind,
+            incomingMessageType: params.incomingMessageType,
+            promptContext: params.promptContext,
+        }),
     ].join('\n');
 }

package/dist/context/resolved-workspace.d.ts

@@ -0,0 +1,2 @@
+import type { PreparedPromptContext, ProviderKind } from '../types.js';
+export declare function buildResolvedWorkspaceGuidanceLines(context: PreparedPromptContext | undefined, provider?: ProviderKind): string[];