@borgee/agents-host 0.2.44 → 0.2.56

package/dist/context/prompt.js

@@ -1,9 +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 { buildSkillManualLines } from './skill-manual.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') {
@@ -40,14 +42,36 @@ function buildLocalhostGatewayPromptLines(context) {
     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.');
+    }
     const collaborationLive = context.localhostGateway.collaboration?.enabled === true
         && (context.collaborationTurnMode ?? 'ordinary') === 'ordinary';
     if (!collaborationLive) {
-        lines.push('Collaboration commands are not available this turn.');
+        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 buildTaskAssignmentPromptLines(params) {
@@ -56,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.',
@@ -65,19 +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}.`);
-        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('Return your normal final response in this thread, and 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'}`,
@@ -86,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) {
@@ -97,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;
@@ -123,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}.`,
@@ -195,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}).`,
@@ -210,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);
@@ -240,5 +506,173 @@ export function buildPrompt(params) {
         '',
         `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[];

package/dist/context/resolved-workspace.js

@@ -0,0 +1,64 @@
+function buildWorkspaceRootLine(context) {
+    const resolvedWorkspace = context.resolvedWorkspace;
+    if (!resolvedWorkspace) {
+        return undefined;
+    }
+    if (resolvedWorkspace.authority === 'task') {
+        return `Writable task-isolated workspace root for this task thread: ${resolvedWorkspace.rootPath}.`;
+    }
+    if (context.taskAssignmentContext?.active === true) {
+        return `Writable workspace root inherited from this task thread's channel: ${resolvedWorkspace.rootPath}.`;
+    }
+    return `Writable workspace root for this channel: ${resolvedWorkspace.rootPath}.`;
+}
+function buildWorkspaceModeLine(context) {
+    if (context.taskAssignmentContext?.active !== true || !context.resolvedWorkspace) {
+        return undefined;
+    }
+    if (context.resolvedWorkspace.authority === 'task') {
+        return 'This task thread runs in a task-isolated workspace instead of inheriting the channel workspace.';
+    }
+    return 'This task thread inherits the channel workspace rather than using a task-isolated workspace.';
+}
+function buildWorkspaceLocalityLine(context) {
+    if (!context.resolvedWorkspace) {
+        return undefined;
+    }
+    if (context.resolvedWorkspace.authority === 'task') {
+        return 'This writable workspace is local to agents-host for this task thread. It does not imply that the target repository has already been checked out there.';
+    }
+    if (context.taskAssignmentContext?.active === true) {
+        return 'This writable workspace is local to agents-host for this task thread because the task inherits its channel workspace. It does not imply that the target repository has already been checked out there.';
+    }
+    return 'This writable workspace is local to agents-host for this channel. It does not imply that the target repository has already been checked out there.';
+}
+function buildCopilotCwdLine(context) {
+    if (!context.resolvedWorkspace) {
+        return undefined;
+    }
+    if (context.resolvedWorkspace.authority === 'task') {
+        return 'GitHub Copilot runs this turn with that task-isolated workspace as its real cwd.';
+    }
+    if (context.taskAssignmentContext?.active === true) {
+        return 'GitHub Copilot runs this turn with that inherited channel workspace as its real cwd.';
+    }
+    return 'GitHub Copilot runs this turn with that workspace as its real cwd.';
+}
+export function buildResolvedWorkspaceGuidanceLines(context, provider) {
+    if (!context?.resolvedWorkspace) {
+        return [];
+    }
+    const lines = [buildWorkspaceRootLine(context), buildWorkspaceModeLine(context)]
+        .filter((line) => line != null);
+    if (provider === 'copilot') {
+        const copilotCwdLine = buildCopilotCwdLine(context);
+        if (copilotCwdLine) {
+            lines.push(copilotCwdLine);
+        }
+    }
+    const localityLine = buildWorkspaceLocalityLine(context);
+    if (localityLine) {
+        lines.push(localityLine);
+    }
+    return lines;
+}

package/dist/context/skill-manual.d.ts

@@ -1,4 +1,5 @@
 import type { SkillRuntimeBootstrapMetadata } from '../types.js';
+export declare function buildSkillManualReadLine(skillRuntime: SkillRuntimeBootstrapMetadata): string;
 /**
  * What every model-facing surface says about the packaged CLI: what it is, where its manual is, and
  * that the manual has to be opened before acting. Nothing else about the CLI is stated on a host

package/dist/context/skill-manual.js

@@ -1,3 +1,6 @@
+export function buildSkillManualReadLine(skillRuntime) {
+    return `Read its manual at ${skillRuntime.skillMarkdownPath} before you act on this channel; it defines both the session-level coordination and delegation contract and the CLI invocation.`;
+}
 /**
  * What every model-facing surface says about the packaged CLI: what it is, where its manual is, and
  * that the manual has to be opened before acting. Nothing else about the CLI is stated on a host
@@ -12,7 +15,7 @@
 export function buildSkillManualLines(skillRuntime) {
     return [
         "A packaged local CLI reads this Borgee channel and acts on its tasks: channel history, visible participants, this channel's tasks and their properties, and short auxiliary mentions.",
-        `Read its manual at ${skillRuntime.skillMarkdownPath} before you act on this channel; you cannot form a working invocation without it.`,
+        buildSkillManualReadLine(skillRuntime),
         'Every command the manual documents is already authorized on a turn whose prompt names a gateway credential file. Run them directly and do not ask the user for permission first.',
     ];
 }