@prestyj/cli 5.30.1 → 5.30.3

package/dist/core/agent-session.d.ts

@@ -6,10 +6,12 @@ import { SlashCommandRegistry } from "./slash-commands.js";
 import { type BranchInfo, type NolanTurnPayload, type AutopilotMarkerPayload, type AppMarkerPayload, type RunOutcome, type TurnMetricPayload } from "./session-manager.js";
 import { type Skill } from "./skills.js";
 import type { BackgroundProcess } from "./process-manager.js";
+import { type ChildModelPick, type SubAgentSnapshot } from "./subagent-manager.js";
 import type { MCPElicitHandler } from "./mcp/index.js";
 import { type ContextLimits } from "./context-limits.js";
 import { type ImportForeignTranscriptResult } from "./foreign-session-import.js";
 import { type CacheExpiryStatus } from "./cache-expiry.js";
+import { type AgentDefinition } from "./agents.js";
 import { type EnhanceResult } from "../utils/prompt-enhancer.js";
 import type { VerificationEvidence } from "./verification-evidence.js";
 /** A chat attachment (image / video / other file) prepared for the model. The
@@ -127,6 +129,45 @@ export interface AgentSessionOptions {
      * agent to skip planning and implement directly. Any other return accepts.
      */
     onEnterPlan?: (reason?: string) => boolean | void | Promise<boolean | void>;
+    /**
+     * Built-in tools to keep in the core set instead of the deferred
+     * tool_search catalog: for a specialist whose job is a deferred tool (GG
+     * Goals orchestrates with spawn_agent and friends). Fixed for the session.
+     */
+    coreTools?: readonly string[];
+    /**
+     * Default provider/model for the workers this session spawns, when their
+     * agent names no model of its own. Read at spawn time.
+     */
+    getChildModel?: () => ChildModelPick | undefined;
+    /**
+     * Wrap each built-in tool once, at registration. Must keep the tool's name,
+     * description and parameters (only `execute` may change), so the tool block
+     * stays prompt-cache stable. Used by EZ Goals to gate its own editing.
+     */
+    wrapTool?: (tool: AgentTool) => AgentTool;
+    /**
+     * Built-in tools this session never has, removed at registration (before
+     * tiering) and left out of the system prompt's Tools section. Unlike
+     * `allowedTools`, the rest of the tool set and its tiering are untouched.
+     * Fixed for the session, so the cached tool block never changes. Used by
+     * EZ Goals, which never edits or runs anything itself.
+     */
+    withoutTools?: readonly string[];
+    /**
+     * A fixed team of sub-agents, replacing agent discovery (project, global
+     * and bundled): the only agents spawn_agent and subagent can start. Used by
+     * EZ Goals, whose workers follow their own rules (goals-agent/goal-team.ts).
+     */
+    subAgents?: readonly AgentDefinition[];
+    /**
+     * Start every spawned child with this session's extra workspace roots too
+     * (less the folder it works in), so it can read and change all of them.
+     * EZ Goals' workers work across all of a goal's attached folders.
+     */
+    shareRootsWithSubAgents?: boolean;
+    /** The sub-agent a spawned child is when the spawn names none (one of `subAgents`). */
+    defaultSubAgent?: string;
     onExitPlan?: (planPath: string) => Promise<ToolExecuteResult>;
     /**
      * If provided, the session's tool set is filtered to ONLY these tool names
@@ -331,6 +372,9 @@ export declare class AgentSession {
      * for no benefit.
      */
     private activeLanguages;
+    /** Languages the model has already been given guidance for, via the system
+     *  prompt or an appended language update. */
+    private announcedLanguages;
     /** Shared with the tool layer so plan-mode restrictions read live state. */
     private planModeRef;
     /** Path of the approved plan currently being implemented, or undefined. When
@@ -684,6 +728,15 @@ export declare class AgentSession {
     /** Clear the queue, returning the combined text (to restore to the composer).
      *  Queued attachments are dropped on cancel — the composer only restores text. */
     drainQueue(): string;
+    /**
+     * Tell the agent a new fact at its next turn, as a short hidden message
+     * appended after the cached prompt (the same channel as a finished worker),
+     * so a mid-session change reaches it without re-rendering the prompt. A
+     * later note with the same id replaces one not yet delivered.
+     */
+    notify(id: string, text: string): void;
+    /** This session's sub-agents (workers), newest-state, including ones restored after a restart. */
+    listSubAgents(): SubAgentSnapshot[];
     /** Snapshot of background processes (bash run_in_background), newest-state. */
     listBackgroundProcesses(): BackgroundProcess[];
     /** Stop a background process by id. Returns a human-readable status string. */
@@ -736,6 +789,13 @@ export declare class AgentSession {
         ok: false;
         error: string;
     }>;
+    /**
+     * Name a root change in the prompt only while there is no conversation yet.
+     * Mid-conversation the env-delta note tells the model instead: the roots sit
+     * in the Environment section, and rewriting it would invalidate every cached
+     * message after it (a goal attaching a folder re-sent ~75k tokens).
+     */
+    private refreshPromptForRoots;
     /**
      * Names to advertise as available-on-demand. A tool the model already
      * promoted lives in `this.tools` and carries its own schema, so it drops out
@@ -758,16 +818,34 @@ export declare class AgentSession {
      * context, return contract and Environment), or the standard prompt.
      */
     private buildBasePrompt;
-    /**
-     * Add newly detected project languages. Returns true when the set grew and
-     * the standard prompt therefore needs a rebuild. Custom and sub-agent
-     * prompts never render packs, so detection is skipped for them.
-     */
     /**
      * Bring the system prompt to the exact state the next provider request will
      * send. Shared by real runs and {@link prewarm} so both see one prefix.
+     *
+     * Languages are re-detected at each task boundary. Before the first reply
+     * nothing is cached worth keeping, so a new language simply rebuilds the
+     * prompt. After that the prompt is a cached prefix and is left alone: the
+     * new language is announced by {@link announceNewLanguages} instead.
      */
     private prepareSystemPromptForRequest;
+    private hasReply;
+    /**
+     * Give the model style packs for languages that appeared after its prompt
+     * was cached (e.g. the previous task scaffolded a TypeScript project), as a
+     * hidden message appended to the history rather than a prompt re-render that
+     * would throw away the whole cache. Runs just before a new user message is
+     * added, so the user's request stays the last thing the model reads and the
+     * update is saved in order with the rest of the conversation.
+     */
+    private announceNewLanguages;
+    /**
+     * Whether this session renders language packs: the standard prompt, and a
+     * code-writing child (a sub-agent prompt with project context). A verbatim
+     * custom prompt never does, nor do user-facing specialist agents (Motion,
+     * goals) or recon children without project context.
+     */
+    private languagesApply;
+    /** Add newly detected project languages. Returns true when the set grew. */
     private refreshActiveLanguages;
     /** Rebuild messages[0] from current plan-mode + approved-plan state. */
     private rebuildSystemPromptInPlace;

package/dist/core/agent-session.js

@@ -27,7 +27,7 @@ import { partitionToolsByTier } from "../tools/tool-tiers.js";
 import { formatImpactForVerification } from "./test-impact.js";
 import { buildProcessCompletionFollowUp } from "./process-gate.js";
 import { PLAN_SUBMISSION_NUDGE, shouldNudgePlanSubmission } from "./plan-submission-gate.js";
-import { buildSubAgentCompletionFollowUp } from "./subagent-manager.js";
+import { buildSubAgentCompletionFollowUp, } from "./subagent-manager.js";
 import { applyAsyncSubagentPolicy } from "./subagent-policy.js";
 import { resolveResponsesLite, resolveStrictTools, } from "./codex-request-shape.js";
 import { subAgentDescription } from "../tools/subagent.js";
@@ -46,14 +46,14 @@ import { decidePlanStepCompaction, DEFAULT_CACHE_WRITE_READ_RATIO, PLAN_STEP_KEE
 import { extractPlanSteps, findCompletedMarkers } from "../utils/plan-steps.js";
 import { readFileSync } from "node:fs";
 import { clampThinkingForPlanMode } from "./thinking-level.js";
-import { pruneStaleToolResults } from "./compaction/tool-result-pruner.js";
+import { pruneStaleToolResults, shouldPruneToolResults } from "./compaction/tool-result-pruner.js";
 import { discoverAgents } from "./agents.js";
 import { enhancePrompt } from "../utils/prompt-enhancer.js";
 import { detectLanguages, detectProjectStack } from "./language-detector.js";
 import { buildLoopBreakMessage } from "./loop-breaker.js";
 import { buildRegroundingMessage, requestTextForRegrounding } from "./regrounding.js";
 import { buildSemanticLoopJudgePrompt, buildSemanticLoopMessage, parseSemanticLoopVerdict, SEMANTIC_LOOP_JUDGE_TIMEOUT_MS, withJudgeTimeout, } from "./semantic-loop-check.js";
-import { buildEnvDeltaMessage } from "./env-delta.js";
+import { buildEnvDeltaMessage, buildLanguageUpdateMessage } from "./env-delta.js";
 import { wrapSteeringText, buildNotificationSteeringText, STEERING_PREFIX } from "./steering.js";
 import { AgentNotificationQueue } from "./agent-notifications.js";
 import { VerificationGate, VERIFICATION_STATE_KIND } from "./verification-gate.js";
@@ -220,6 +220,9 @@ export class AgentSession {
      * for no benefit.
      */
     activeLanguages = new Set();
+    /** Languages the model has already been given guidance for, via the system
+     *  prompt or an appended language update. */
+    announcedLanguages = new Set();
     /** Shared with the tool layer so plan-mode restrictions read live state. */
     planModeRef = { current: false };
     /** Path of the approved plan currently being implemented, or undefined. When
@@ -309,7 +312,10 @@ export class AgentSession {
         // Session manager. Agent-specific roots keep chat and coder histories isolated.
         this.sessionManager = new SessionManager(this.opts.sessionRootDir ?? paths.sessionsDir);
         const projectCustomization = this.opts.projectCustomization !== false;
-        if (projectCustomization) {
+        // A sub-agent worker never creates them: the session that owns the
+        // project does. EZ Goals' workers work in the user's attached folders,
+        // which mustn't gain empty .ezcoder folders as a side effect.
+        if (projectCustomization && !this.opts.subagentWorker) {
             // Ensure project-local .ezcoder directories exist.
             const localEzDir = path.join(this.cwd, ".ezcoder");
             await fs.mkdir(path.join(localEzDir, "skills"), { recursive: true });
@@ -330,16 +336,20 @@ export class AgentSession {
         }
         // Discover agents and create tools (with sub-agent support). Chat sessions
         // can retain bundled workers without loading project/global customization.
-        const agents = projectCustomization
-            ? await discoverAgents({
-                globalAgentsDir: paths.agentsDir,
-                projectDir: this.cwd,
-            })
-            : this.opts.globalSubagents
-                ? await discoverAgents({ globalAgentsDir: paths.agentsDir })
-                : [];
+        const agents = this.opts.subAgents
+            ? [...this.opts.subAgents]
+            : projectCustomization
+                ? await discoverAgents({
+                    globalAgentsDir: paths.agentsDir,
+                    projectDir: this.cwd,
+                })
+                : this.opts.globalSubagents
+                    ? await discoverAgents({ globalAgentsDir: paths.agentsDir })
+                    : [];
         const { tools: builtInTools, processManager, rebuildReadTool, clearReadTracker, recordBashReads, lspManager, testImpact, debugManager, subAgentManager, } = await createTools(this.cwd, {
             agents,
+            shareWorkspaceRoots: this.opts.shareRootsWithSubAgents,
+            defaultSubAgent: this.opts.defaultSubAgent,
             skills: this.skills,
             contextLimits: this.contextLimits,
             provider: this.provider,
@@ -381,6 +391,7 @@ export class AgentSession {
             getBaseUrl: () => this.baseUrl,
             getCacheKey: () => this.getPromptCacheKey(),
             getMaxPerModel: () => this.settingsManager.get("subagentMaxPerModel"),
+            getChildModel: this.opts.getChildModel,
             // A persistent child is already the single allowed fan-out level. Blocking
             // `subagent` here created a timeout sandwich: the nested call could consume
             // the child's entire 10-minute turn budget, discarding all nested results.
@@ -408,6 +419,16 @@ export class AgentSession {
         // a hallucinated call can't mutate the repo — and buildSystemPrompt below is
         // fed the same filtered names so the Tools section matches exactly.
         this.tools = this.opts.allowedTools ? tools.filter((t) => this.isToolAllowed(t.name)) : tools;
+        const without = new Set(this.opts.withoutTools ?? []);
+        if (without.size > 0)
+            this.tools = this.tools.filter((t) => !without.has(t.name));
+        // A host may wrap built-ins (EZ Goals holds back its own editing once a
+        // goal is underway). Same names and schemas, so the cached tool block and
+        // the system prompt's Tools section are unchanged.
+        if (this.opts.wrapTool) {
+            const wrap = this.opts.wrapTool;
+            this.tools = this.tools.map((t) => wrap(t));
+        }
         // Both delegation tools carry the agent roster; when both survive the
         // allow-list, `subagent` points at `spawn_agent`'s copy instead.
         if (this.tools.some((t) => t.name === "spawn_agent")) {
@@ -422,7 +443,14 @@ export class AgentSession {
             // catalog must hold the wrapped tool so a promoted spawn still loads
             // wait_agent.
             this.promoteFollowUpTools();
-            const { core, deferred } = partitionToolsByTier(this.tools);
+            const partition = partitionToolsByTier(this.tools);
+            // A session can keep chosen built-ins in its core set (EZ Goals
+            // orchestrates, so its agent tools are always at hand). Fixed for the
+            // session, so the cached tool block stays byte-stable.
+            const keep = new Set(this.opts.coreTools ?? []);
+            const deferred = partition.deferred.filter((t) => !keep.has(t.name));
+            // Everything not deferred, in the original relative order.
+            const core = keep.size > 0 ? this.tools.filter((t) => !deferred.includes(t)) : partition.core;
             if (deferred.length > 0) {
                 // Append-only: `core` preserves the original relative order and
                 // tool_search is pushed after it, so the serialized tool block that
@@ -454,6 +482,9 @@ export class AgentSession {
         else {
             await this.connectMcpServers();
         }
+        // Detect languages before the first render so the opening prompt already
+        // carries their packs and only a genuinely new language needs an update.
+        this.refreshActiveLanguages();
         const basePrompt = await this.buildBasePrompt(false, undefined);
         this.baseSystemPrompt = basePrompt;
         this.messages = [{ role: "system", content: this.withSystemPromptTail(basePrompt) }];
@@ -786,6 +817,7 @@ export class AgentSession {
         if (slash?.kind === "template") {
             // Prompt templates remain human-originated: the user invoked the command.
             const userMessage = { role: "user", content: slash.fullPrompt, provenance };
+            await this.announceNewLanguages();
             this.messages.push(userMessage);
             await this.persistMessage(userMessage);
             this.lastPersistedIndex = this.messages.length;
@@ -802,6 +834,7 @@ export class AgentSession {
         }
         // Push user message
         const userMessage = { role: "user", content, provenance };
+        await this.announceNewLanguages();
         this.messages.push(userMessage);
         await this.persistMessage(userMessage);
         this.lastPersistedIndex = this.messages.length;
@@ -826,6 +859,7 @@ export class AgentSession {
             content: parts,
             provenance: { source: "human", kind: "prompt", visibility: "transcript" },
         };
+        await this.announceNewLanguages();
         this.messages.push(userMessage);
         await this.persistMessage(userMessage);
         this.lastPersistedIndex = this.messages.length;
@@ -1713,36 +1747,6 @@ export class AgentSession {
                     if (!force) {
                         if (!this.settingsManager.get("autoCompact"))
                             return messages;
-                        // Cheap stale-tool-output pruning before the expensive LLM
-                        // compaction check. In-place mutation preserves anchors; drop the
-                        // retained usage afterwards since it counted the pruned content.
-                        const pruneResult = pruneStaleToolResults(messages);
-                        if (pruneResult.pruned) {
-                            this.cacheDiagnostics.noteEdit("tool_prune", pruneResult.freedTokens);
-                            this.providerContext = null;
-                            log("INFO", "compaction", "Pruned stale tool outputs", {
-                                prunedResults: String(pruneResult.prunedResults),
-                                compactedToolCalls: String(pruneResult.compactedToolCalls),
-                                freedTokens: String(pruneResult.freedTokens),
-                            });
-                        }
-                        if (Date.now() < this.compactionRetryAfter)
-                            return messages;
-                        // The turn's own usage also counted the pruned content — after a
-                        // prune, fall back to estimating the (now smaller) history so the
-                        // freed tokens actually defer the LLM compaction.
-                        let usage = pruneResult.pruned ? undefined : transformOpts.usage;
-                        let pendingMessages = transformOpts.pendingMessages;
-                        if (!usage && this.providerContext) {
-                            const anchorIndex = messages.lastIndexOf(this.providerContext.anchor);
-                            if (anchorIndex >= 0) {
-                                usage = this.providerContext.usage;
-                                pendingMessages = messages.slice(anchorIndex + 1);
-                            }
-                            else {
-                                this.providerContext = null;
-                            }
-                        }
                         const contextWindow = getContextWindow(this.model, {
                             provider: this.provider,
                             accountId,
@@ -1755,10 +1759,48 @@ export class AgentSession {
                             accountId,
                             approvedPlanPath: this.approvedPlanPath,
                         });
-                        const activeTokens = calculateActiveContextTokens(messages, {
-                            usage,
-                            pendingMessages,
-                        });
+                        // Provider usage when there is some, else an estimate of the history.
+                        const measureActiveTokens = () => {
+                            let usage = transformOpts.usage;
+                            let pendingMessages = transformOpts.pendingMessages;
+                            if (!usage && this.providerContext) {
+                                const anchorIndex = messages.lastIndexOf(this.providerContext.anchor);
+                                if (anchorIndex >= 0) {
+                                    usage = this.providerContext.usage;
+                                    pendingMessages = messages.slice(anchorIndex + 1);
+                                }
+                                else {
+                                    this.providerContext = null;
+                                }
+                            }
+                            return calculateActiveContextTokens(messages, { usage, pendingMessages });
+                        };
+                        let activeTokens = measureActiveTokens();
+                        // Cheap stale-tool-output pruning before the expensive LLM
+                        // compaction check, once the context is big enough for the freed
+                        // tokens to be worth a cache rewrite. In-place mutation preserves
+                        // anchors; drop the retained usage afterwards since it counted the
+                        // pruned content.
+                        if (shouldPruneToolResults(activeTokens, policy.targetTokens)) {
+                            const pruneResult = pruneStaleToolResults(messages);
+                            if (pruneResult.pruned) {
+                                this.cacheDiagnostics.noteEdit("tool_prune", pruneResult.freedTokens);
+                                this.providerContext = null;
+                                log("INFO", "compaction", "Pruned stale tool outputs", {
+                                    prunedResults: String(pruneResult.prunedResults),
+                                    compactedToolCalls: String(pruneResult.compactedToolCalls),
+                                    freedTokens: String(pruneResult.freedTokens),
+                                });
+                                // The turn's own usage also counted the pruned content — estimate
+                                // the (now smaller) history so the freed tokens actually defer
+                                // the LLM compaction.
+                                activeTokens = calculateActiveContextTokens(messages, {
+                                    pendingMessages: transformOpts.pendingMessages,
+                                });
+                            }
+                        }
+                        if (Date.now() < this.compactionRetryAfter)
+                            return messages;
                         // An approved plan runs as ONE run, so step boundaries are only
                         // visible here, between model steps — not after the run ends.
                         const planStep = this.observePlanStepProgress(messages, contextWindow, activeTokens);
@@ -2510,6 +2552,9 @@ export class AgentSession {
         // new session's /history, and get re-persisted into the new file by the
         // next compaction — the cross-session duplicate-marker propagation bug.
         this.markers.clear();
+        // Detect languages before the first render so the opening prompt already
+        // carries their packs and only a genuinely new language needs an update.
+        this.refreshActiveLanguages();
         const basePrompt = await this.buildBasePrompt(false, undefined);
         this.baseSystemPrompt = basePrompt;
         this.messages = [{ role: "system", content: this.withSystemPromptTail(basePrompt) }];
@@ -2713,6 +2758,19 @@ export class AgentSession {
             .map((m) => m.text)
             .join("\n\n");
     }
+    /**
+     * Tell the agent a new fact at its next turn, as a short hidden message
+     * appended after the cached prompt (the same channel as a finished worker),
+     * so a mid-session change reaches it without re-rendering the prompt. A
+     * later note with the same id replaces one not yet delivered.
+     */
+    notify(id, text) {
+        this.notifications.enqueue("goal", id, text, { terminal: true });
+    }
+    /** This session's sub-agents (workers), newest-state, including ones restored after a restart. */
+    listSubAgents() {
+        return this.subAgentManager?.list() ?? [];
+    }
     /** Snapshot of background processes (bash run_in_background), newest-state. */
     listBackgroundProcesses() {
         return this.processManager?.list() ?? [];
@@ -2811,7 +2869,7 @@ export class AgentSession {
             return relative.startsWith("..") || path.isAbsolute(relative);
         });
         this.additionalRoots.push(resolved);
-        await this.rebuildSystemPromptInPlace();
+        await this.refreshPromptForRoots();
         return { ok: true, root: resolved };
     }
     /** Remove an exact root previously added with `/add-dir`. */
@@ -2822,9 +2880,20 @@ export class AgentSession {
             return { ok: false, error: `Not an additional workspace root: ${resolved}` };
         }
         this.additionalRoots.splice(index, 1);
-        await this.rebuildSystemPromptInPlace();
+        await this.refreshPromptForRoots();
         return { ok: true, root: resolved };
     }
+    /**
+     * Name a root change in the prompt only while there is no conversation yet.
+     * Mid-conversation the env-delta note tells the model instead: the roots sit
+     * in the Environment section, and rewriting it would invalidate every cached
+     * message after it (a goal attaching a folder re-sent ~75k tokens).
+     */
+    async refreshPromptForRoots() {
+        if (this.messages.some((message) => message.role !== "system"))
+            return;
+        await this.rebuildSystemPromptInPlace();
+    }
     /**
      * Names to advertise as available-on-demand. A tool the model already
      * promoted lives in `this.tools` and carries its own schema, so it drops out
@@ -2865,6 +2934,8 @@ export class AgentSession {
             return this.customSystemPrompt;
         const toolNames = this.tools.map((tool) => tool.name);
         const deferredToolNames = this.deferredToolNamesForPrompt(toolNames);
+        // Whatever is rendered now is what the model has been told.
+        this.announcedLanguages = new Set(this.activeLanguages);
         if (this.agentPrompt !== undefined) {
             return buildSubAgentSystemPrompt(this.agentPrompt, {
                 cwd: this.cwd,
@@ -2874,29 +2945,73 @@ export class AgentSession {
                 role: this.opts.agentRole,
                 environment: this.recordRenderedEnvironment(),
                 contextLimits: this.contextLimits,
+                ...(this.languagesApply() ? { activeLanguages: this.activeLanguages } : {}),
             });
         }
         return buildSystemPrompt(this.cwd, this.skills, planMode, approvedPlanPath, toolNames, this.activeLanguages, this.provider, this.recordRenderedEnvironment(), deferredToolNames, this.contextLimits);
     }
-    /**
-     * Add newly detected project languages. Returns true when the set grew and
-     * the standard prompt therefore needs a rebuild. Custom and sub-agent
-     * prompts never render packs, so detection is skipped for them.
-     */
     /**
      * Bring the system prompt to the exact state the next provider request will
      * send. Shared by real runs and {@link prewarm} so both see one prefix.
+     *
+     * Languages are re-detected at each task boundary. Before the first reply
+     * nothing is cached worth keeping, so a new language simply rebuilds the
+     * prompt. After that the prompt is a cached prefix and is left alone: the
+     * new language is announced by {@link announceNewLanguages} instead.
      */
     async prepareSystemPromptForRequest() {
-        // Languages are re-detected at each task boundary so a project scaffolded
-        // during the previous turn gets its packs; the prompt is rebuilt only when
-        // the set grows, keeping the cached prefix stable otherwise.
-        if (this.refreshActiveLanguages())
+        if (this.refreshActiveLanguages() && !this.hasReply()) {
             await this.rebuildSystemPromptInPlace();
+        }
         this.refreshSystemPromptTail();
     }
+    hasReply() {
+        return this.messages.some((m) => m.role === "assistant");
+    }
+    /**
+     * Give the model style packs for languages that appeared after its prompt
+     * was cached (e.g. the previous task scaffolded a TypeScript project), as a
+     * hidden message appended to the history rather than a prompt re-render that
+     * would throw away the whole cache. Runs just before a new user message is
+     * added, so the user's request stays the last thing the model reads and the
+     * update is saved in order with the rest of the conversation.
+     */
+    async announceNewLanguages() {
+        if (!this.hasReply())
+            return; // the next request rebuilds the prompt instead
+        this.refreshActiveLanguages();
+        const fresh = new Set([...this.activeLanguages].filter((id) => !this.announcedLanguages.has(id)));
+        if (fresh.size === 0)
+            return;
+        for (const id of fresh)
+            this.announcedLanguages.add(id);
+        const update = buildLanguageUpdateMessage(fresh, this.cwd);
+        if (!update)
+            return;
+        this.messages.push(update);
+        await this.persistMessage(update);
+        this.lastPersistedIndex = this.messages.length;
+        log("INFO", "language", "Appended style packs for new languages", {
+            added: [...fresh].join(","),
+        });
+    }
+    /**
+     * Whether this session renders language packs: the standard prompt, and a
+     * code-writing child (a sub-agent prompt with project context). A verbatim
+     * custom prompt never does, nor do user-facing specialist agents (Motion,
+     * goals) or recon children without project context.
+     */
+    languagesApply() {
+        if (this.customSystemPrompt)
+            return false;
+        if (this.agentPrompt === undefined)
+            return true;
+        return ((this.opts.agentRole ?? "subagent") === "subagent" &&
+            (this.opts.agentContext ?? "project") === "project");
+    }
+    /** Add newly detected project languages. Returns true when the set grew. */
     refreshActiveLanguages() {
-        if (this.customSystemPrompt || this.agentPrompt !== undefined)
+        if (!this.languagesApply())
             return false;
         let grew = false;
         try {