@promptbook/cli 0.114.0-41 → 0.114.0-47

package/esm/scripts/find-fresh-emoji-tags/find-fresh-emoji-tags.d.ts

@@ -3,4 +3,4 @@
  *
  * @public exported from `@promptbook/cli`
  */
-export declare function findFreshEmojiTag(): Promise<void>;
+export declare function findFreshEmojiTag(projectPath?: string): Promise<void>;

package/esm/scripts/find-refactor-candidates/find-refactor-candidates.d.ts

@@ -11,6 +11,8 @@ export declare function findRefactorCandidates(options?: FindRefactorCandidatesO
  * @public exported from `@promptbook/cli`
  */
 export type FindRefactorCandidatesOptions = {
+    /** Explicit project directory retained separately from any enclosing repository. */
+    readonly projectPath?: string;
     /**
      * Aggressiveness level used to score candidate files.
      */

package/esm/scripts/find-refactor-candidates/resolveRefactorCandidateProject.d.ts

@@ -20,4 +20,6 @@ export type ResolvedRefactorCandidateProject = {
  *
  * @private function of findRefactorCandidates
  */
-export declare function resolveRefactorCandidateProject(startDir: string): Promise<ResolvedRefactorCandidateProject>;
+export declare function resolveRefactorCandidateProject(startDir: string, options?: {
+    readonly isPreservingProjectDirectory?: boolean;
+}): Promise<ResolvedRefactorCandidateProject>;

package/esm/scripts/run-codex-prompts/common/CoderRunControlFeedback.d.ts

@@ -3,7 +3,7 @@
  *
  * @private internal type of `ptbk coder` terminal controls
  */
-export type CoderRunControlKey = 'P' | 'S' | 'X';
+export type CoderRunControlKey = 'P' | 'S' | 'X' | 'O';
 /**
  * Meaning of one control answer, which decides how it is colored in the terminal.
  *

package/esm/scripts/run-codex-prompts/common/buildCoderRunControlKeyBadge.d.ts

@@ -4,4 +4,4 @@ import type { CoderRunControlKey } from './CoderRunControlFeedback';
  *
  * @private internal utility of `ptbk coder` terminal controls
  */
-export declare function buildCoderRunControlKeyBadge(controlKey: CoderRunControlKey): string;
+export declare function buildCoderRunControlKeyBadge(controlKey: CoderRunControlKey, isBracketed?: boolean): string;

package/esm/scripts/run-codex-prompts/common/listenForCoderRunControls.d.ts

@@ -1,8 +1,9 @@
 /**
  * Listens for the terminal control keys while the plain console output is used.
  *
- * Every recognized key press is answered with one printed line, because the plain mode has no frame
- * which could show the new state on its own. The rich terminal UI installs its own listener in
+ * Every recognized key press is answered with one printed line when stdout is a terminal. Redirecting
+ * stdout keeps existing stdin controls working without mixing control feedback into logs.
+ * The rich terminal UI installs its own listener in
  * [`renderCoderRunUi`](../ui/renderCoderRunUi.ts) and shares the very same key handling through
  * [`applyCoderRunControlKey`](./applyCoderRunControlKey.ts).
  *

package/esm/scripts/run-codex-prompts/common/resolveCoderAgent.d.ts

@@ -1,4 +1,6 @@
 import type { string_book } from '../../../src/book-2.0/agent-source/string_book';
+import { type CoderAgentRole } from '../../../src/cli/cli-commands/coder/coderAgentRole';
+import type { CoderTeamAgent } from '../team/CoderTeamAgent';
 /**
  * Source and prompt-routing references resolved from an optional `--agent` book file.
  */
@@ -26,6 +28,8 @@ export type ResolvedCoderAgentBook = {
  * Agent data resolved from the optional `--agent` book file.
  */
 export type ResolvedCoderAgent = ResolvedCoderAgentBook & {
+    /** Compiled TEAM schemas and a session-scoped loader for each adviser's own effective Book. */
+    readonly teamAgent: CoderTeamAgent;
     /** Source with inheritance and imports applied, also used for the coder's agent visual. */
     readonly agentSource: string_book;
     /**
@@ -38,12 +42,18 @@ export type ResolvedCoderAgent = ResolvedCoderAgentBook & {
 /**
  * Reads an optional agent `.book` file and prepares the references that route prompts to it.
  *
- * Returns `undefined` when no agent path is provided.
+ * Returns `undefined` when neither an explicit path nor an execution role is provided (list has no default).
  */
-export declare function resolveCoderAgentBook(agentBookReference: string | undefined, currentWorkingDirectory: string): Promise<ResolvedCoderAgentBook | undefined>;
+export declare function resolveCoderAgentBook(agentBookReference: string | undefined, currentWorkingDirectory: string, options?: {
+    readonly defaultRole?: CoderAgentRole;
+}): Promise<ResolvedCoderAgentBook | undefined>;
 /**
- * Reads an optional agent `.book` file and compiles its system message for injection into coder prompts.
+ * Reads the explicitly selected or command-default agent Book and compiles its system message for coder prompts.
  *
- * Returns `undefined` when no agent path is provided.
+ * Returns `undefined` when neither an explicit path nor a command default is provided.
  */
-export declare function resolveCoderAgent(agentBookReference: string | undefined, currentWorkingDirectory: string): Promise<ResolvedCoderAgent | undefined>;
+export declare function resolveCoderAgent(agentBookReference: string | undefined, currentWorkingDirectory: string, options?: {
+    readonly defaultRole?: CoderAgentRole;
+    readonly isInitializationAllowed?: boolean;
+    readonly signal?: AbortSignal;
+}): Promise<ResolvedCoderAgent | undefined>;

package/esm/scripts/run-codex-prompts/common/runGoScript/$spawnLoggedBashScript.d.ts

@@ -6,6 +6,8 @@ import { type ChildProcessWithoutNullStreams } from 'child_process';
  * @private internal type of `$spawnLoggedBashScript`
  */
 type SpawnLoggedBashScriptOptions = {
+    /** Per-invocation cwd, shared by the primary harness and its advisers. */
+    readonly projectPath?: string;
     readonly scriptPath: string;
     readonly logPath?: string;
     /**

package/esm/scripts/run-codex-prompts/common/runGoScript/captureLiveScriptOutput.d.ts

@@ -0,0 +1,9 @@
+/** Original stream identity, retained independently of the dashboard projection. */
+export type LiveScriptOutputSource = 'stdout' | 'stderr' | 'team';
+/** A presentation observer returns true only while it owns terminal output. */
+type LiveScriptOutputCapture = (chunk: string, source: LiveScriptOutputSource) => boolean;
+/** Installs the dashboard's optional presentation sink and returns its disposer. */
+export declare function subscribeToLiveScriptOutput(capture: LiveScriptOutputCapture): () => void;
+/** Offers an already produced chunk to the dashboard. A display failure cannot fail a script. */
+export declare function captureLiveScriptOutput(chunk: string | (() => string), source: LiveScriptOutputSource): boolean;
+export {};

package/esm/scripts/run-codex-prompts/common/runGoScript/createScriptOutputLineReader.d.ts

@@ -8,6 +8,10 @@ export type ScriptOutputLineReader = {
      * Returns every line which the given chunk has completed, keeping the unterminated rest for the next chunk.
      */
     readCompletedLines(chunk: string): readonly string[];
+    /** Reads the pending fragment without treating it as a complete protocol record. */
+    getPendingLine(): string;
+    /** Drains a final unterminated line when a presentation capture ends. */
+    flush(): string;
 };
 /**
  * Creates a line reader for one shell output stream.

package/esm/scripts/run-codex-prompts/common/runGoScript/resolveShellHereDocumentDelimiter.d.ts

@@ -0,0 +1,2 @@
+/** Chooses a delimiter absent from Book text so untrusted instructions stay stdin data, never shell code. */
+export declare function resolveShellHereDocumentDelimiter(baseDelimiter: string, content: string): string;

package/esm/scripts/run-codex-prompts/common/runGoScript/scriptExecutionLog.d.ts

@@ -13,6 +13,8 @@ export declare const SCRIPT_EXECUTION_LOG_RAW_OUTPUT_MARKER = "--- raw output --
  * Environment variable that identifies the Node process responsible for a temporary harness shell.
  */
 export declare const PTBK_CODER_PARENT_PROCESS_ID_ENV_NAME = "PTBK_CODER_PARENT_PROCESS_ID";
+/** Private stdin command asks the owning wrapper to stop its actual harness job before exiting. */
+export declare const PTBK_CODER_CANCEL_COMMAND = "PTBK_CANCEL_OWNED_HARNESS";
 /**
  * Shapes one bash invocation that optionally mirrors live script output into a temporary log file.
  */

package/esm/scripts/run-codex-prompts/git/coderCommitScope.d.ts

@@ -1,3 +1,4 @@
+import { type WorkspaceRepositoryContext } from '../../../src/cli/cli-commands/common/workspaceRepository';
 import type { WorkingTreeChangesSnapshot } from './workingTreeChanges';
 /**
  * Working tree state captured right before one `ptbk coder` operation starts changing the project.
@@ -10,6 +11,8 @@ export type CoderCommitScope = {
      * Project the operation runs in.
      */
     readonly projectPath: string;
+    /** Enclosing Git root used for repository-relative snapshots and pathspecs. */
+    readonly repositoryRoot?: string;
     /**
      * Files which were already changed before the operation started.
      */
@@ -21,7 +24,7 @@ export type CoderCommitScope = {
  * The captured scope is passed to the commit of the very same operation, which then commits exactly the files
  * this operation has created, changed, moved or deleted.
  */
-export declare function captureCoderCommitScope(projectPath: string): Promise<CoderCommitScope>;
+export declare function captureCoderCommitScope(project: string | WorkspaceRepositoryContext): Promise<CoderCommitScope>;
 /**
  * Resolves the repository-relative paths which one `ptbk coder` operation has really changed.
  *

package/esm/scripts/run-codex-prompts/git/coderGitSync.d.ts

@@ -1,3 +1,4 @@
+import { type WorkspaceRepositoryContext } from '../../../src/cli/cli-commands/common/workspaceRepository';
 import type { CoderCommitScope } from './coderCommitScope';
 /**
  * Automatic git synchronization of the project changes made by one `ptbk coder` command.
@@ -35,6 +36,7 @@ export declare const DISABLED_CODER_GIT_SYNC_OPTIONS: CoderGitSyncOptions;
 export declare function $startCoderGitSync(options: {
     readonly gitSync: CoderGitSyncOptions;
     readonly projectPath?: string;
+    readonly workspace?: WorkspaceRepositoryContext;
 }): Promise<CoderCommitScope>;
 /**
  * Pulls the latest repository changes before a `ptbk coder` command changes the project.
@@ -42,6 +44,7 @@ export declare function $startCoderGitSync(options: {
 export declare function $pullCoderChanges(options: {
     readonly gitSync: CoderGitSyncOptions;
     readonly projectPath?: string;
+    readonly workspace?: WorkspaceRepositoryContext;
 }): Promise<void>;
 /**
  * Commits - and when requested also pushes - the changes one `ptbk coder` command has just made.
@@ -53,4 +56,6 @@ export declare function $commitCoderChanges(options: {
     readonly gitSync: CoderGitSyncOptions;
     readonly commitMessage: string;
     readonly commitScope: CoderCommitScope;
+    /** Optional explicit write set, used by long-running authoring sessions to exclude concurrent user edits. */
+    readonly relevantPaths?: ReadonlyArray<string>;
 }): Promise<void>;

package/esm/scripts/run-codex-prompts/git/commitInitializedAgentBooks.d.ts

@@ -1,5 +1,6 @@
+import type { WorkspaceRepositoryContext } from '../../../src/cli/cli-commands/common/workspaceRepository';
 /**
  * Commits newly initialized, non-ignored agent books before the coder's clean-tree checkpoint.
  * Only books created by this run are eligible; existing books and unrelated changes remain outside the commit.
  */
-export declare function commitInitializedAgentBooks(projectPath: string, createdAgentBookPaths: ReadonlyArray<string>): Promise<void>;
+export declare function commitInitializedAgentBooks(projectPath: string, createdAgentBookPaths: ReadonlyArray<string>, workspace?: WorkspaceRepositoryContext): Promise<void>;

package/esm/scripts/run-codex-prompts/git/ensureWorkingTreeClean.d.ts

@@ -1,4 +1,4 @@
 /**
  * Ensures the git working tree is clean before running the prompt.
  */
-export declare function ensureWorkingTreeClean(): Promise<void>;
+export declare function ensureWorkingTreeClean(repositoryRoot?: string): Promise<void>;

package/esm/scripts/run-codex-prompts/isolation/copyCoderIsolationEnvironment.d.ts

@@ -5,4 +5,4 @@ import type { CoderIsolationWorktree } from './CoderIsolationWorktree';
  * The copy is intentionally a snapshot: changing the environment inside the worktree never leaks
  * back into the project the coder was started from.
  */
-export declare function copyCoderIsolationEnvironment(worktree: CoderIsolationWorktree): Promise<void>;
+export declare function copyCoderIsolationEnvironment(worktree: CoderIsolationWorktree, isolatedProjectPath?: string): Promise<void>;

package/esm/scripts/run-codex-prompts/isolation/createCoderIsolationWorktree.d.ts

@@ -7,6 +7,8 @@ type CreateCoderIsolationWorktreeOptions = {
      * Absolute path of the project the coder was started from.
      */
     readonly projectPath: string;
+    /** Enclosing Git root, which can differ from the requested project directory. */
+    readonly repositoryRoot?: string;
     /**
      * Name of the isolated task, for example `2026-07-0700-ptbk-coder-timing`.
      */

package/esm/scripts/run-codex-prompts/main/findUnwrittenPrompts.d.ts

@@ -7,6 +7,8 @@ export type FindUnwrittenPromptsOptions = {
      * @default 0
      */
     readonly priority?: number;
+    /** Resolved project directory supplied by the CLI. */
+    readonly projectPath?: string;
 };
 /**
  * Lists and prints all prompt sections that still need to be authored (contain `@@@` placeholder).

package/esm/scripts/run-codex-prompts/main/listCoderPrompts.d.ts

@@ -6,6 +6,8 @@ import type { PromptRunnerIdentity } from '../prompts/isPromptCompatibleWithRunn
  * @public exported from `@promptbook/cli`
  */
 export type ListCoderPromptsOptions = PriorityFilterInput & {
+    /** Resolved project directory supplied by the CLI. */
+    readonly projectPath?: string;
     /**
      * Optional harness, model and Book-agent selection used to omit prompts routed to other runners.
      */

package/esm/scripts/run-codex-prompts/main/resolvePromptRunner.d.ts

@@ -1,3 +1,4 @@
+import type { PromptRunnerHarnessName } from '../../../src/cli/cli-commands/common/promptRunnerCliOptions';
 import type { RunOptions } from '../cli/RunOptions';
 import type { PromptRunnerMetadata } from '../common/PromptRunnerMetadata';
 import type { PromptRunner } from '../runners/types/PromptRunner';
@@ -25,4 +26,14 @@ type PromptRunnerResolution = {
  * @private function of runCodexPrompts
  */
 export declare function resolvePromptRunner(options: PromptRunnerSelectionOptions): PromptRunnerResolution;
+/**
+ * Uses the current flagship when no model is selected, while preserving explicit overrides.
+ *
+ * `--model default` keeps the harness's own configured model where supported. Gemini, Qwen and Cline
+ * require a concrete model in their adapters, so the sentinel selects their shared default instead.
+ * Read-only previews use the same policy without constructing a harness runner.
+ *
+ * @private internal utility of Coder execution and previews
+ */
+export declare function resolveRunnerModel(agentName: PromptRunnerHarnessName, providedModel?: string): string | undefined;
 export {};

package/esm/scripts/run-codex-prompts/prompts/loadPromptFiles.d.ts

@@ -1,5 +1,13 @@
 import type { PromptFile } from './types/PromptFile';
 /**
- * Loads and parses prompt files from the prompts directory, excluding files marked for `ptbk coder` to ignore.
+ * HTML comment which excludes a Markdown file from all `ptbk coder` queues.
+ *
+ * @private internal constant of `loadPromptFiles`
  */
-export declare function loadPromptFiles(promptsDir: string): Promise<PromptFile[]>;
+export declare const PTBK_CODER_IGNORE_MARKER = "<!--ptbk-coder-ignore-->";
+/**
+ * Loads top-level PRDs, excluding the README and files marked for `ptbk coder` to ignore.
+ */
+export declare function loadPromptFiles(promptsDir: string, options?: {
+    readonly isMissingDirectoryAllowed?: boolean;
+}): Promise<PromptFile[]>;

package/esm/scripts/run-codex-prompts/runners/claude-code/ClaudeCodeRunner.d.ts

@@ -8,6 +8,8 @@ import type { ClaudeCodeRunnerOptions } from './ClaudeCodeRunnerOptions';
  */
 export declare class ClaudeCodeRunner implements PromptRunner {
     private readonly options;
+    /** TEAM uses this harness's existing command tool, with the same permissions as its caller. */
+    readonly teamCapability: "command-tools";
     readonly name = "claude-code";
     private subscriptionUsage;
     /**

package/esm/scripts/run-codex-prompts/runners/cline/ClineRunner.d.ts

@@ -7,6 +7,8 @@ import type { ClineRunnerOptions } from './ClineRunnerOptions';
  */
 export declare class ClineRunner implements PromptRunner {
     private readonly options;
+    /** TEAM uses this harness's existing command tool, with the same permissions as its caller. */
+    readonly teamCapability: "command-tools";
     readonly name = "cline";
     /**
      * Creates a new Cline runner.

package/esm/scripts/run-codex-prompts/runners/gemini/GeminiRunner.d.ts

@@ -11,6 +11,8 @@ export declare const DEFAULT_GEMINI_MODEL: "gemini-3.8-flash";
  */
 export declare class GeminiRunner implements PromptRunner {
     private readonly options;
+    /** TEAM uses this harness's existing command tool, with the same permissions as its caller. */
+    readonly teamCapability: "command-tools";
     readonly name = "gemini";
     /**
      * Creates a new Gemini runner.

package/esm/scripts/run-codex-prompts/runners/github-copilot/GitHubCopilotRunner.d.ts

@@ -7,6 +7,8 @@ import type { GitHubCopilotRunnerOptions } from './GitHubCopilotRunnerOptions';
  */
 export declare class GitHubCopilotRunner implements PromptRunner {
     private readonly options;
+    /** TEAM uses this harness's existing command tool, with the same permissions as its caller. */
+    readonly teamCapability: "command-tools";
     readonly name = "github-copilot";
     /**
      * Creates a new GitHub Copilot runner.

package/esm/scripts/run-codex-prompts/runners/openai-codex/OpenAiCodexRunner.d.ts

@@ -8,6 +8,8 @@ import type { OpenAiCodexRunnerOptions } from './OpenAiCodexRunnerOptions';
  */
 export declare class OpenAiCodexRunner implements PromptRunner {
     private readonly options;
+    /** TEAM uses this harness's existing command tool, with the same permissions as its caller. */
+    readonly teamCapability: "command-tools";
     readonly name = "codex";
     private readonly rateLimitBackoff;
     /**

package/esm/scripts/run-codex-prompts/runners/opencode/OpencodeRunner.d.ts

@@ -7,6 +7,8 @@ import type { OpencodeRunnerOptions } from './OpencodeRunnerOptions';
  */
 export declare class OpencodeRunner implements PromptRunner {
     private readonly options;
+    /** TEAM uses this harness's existing command tool, with the same permissions as its caller. */
+    readonly teamCapability: "command-tools";
     readonly name = "opencode";
     /**
      * Creates a new Opencode runner.

package/esm/scripts/run-codex-prompts/runners/qwen-code/QwenCodeRunner.d.ts

@@ -11,6 +11,8 @@ export declare const DEFAULT_QWEN_CODE_MODEL: "qwen3.8-max";
  */
 export declare class QwenCodeRunner implements PromptRunner {
     private readonly options;
+    /** TEAM uses this harness's existing command tool, with the same permissions as its caller. */
+    readonly teamCapability: "command-tools";
     readonly name = "qwen-code";
     /**
      * Creates a new Qwen Code runner.

package/esm/scripts/run-codex-prompts/server/runCoderHttpServer.d.ts

@@ -1,3 +1,4 @@
+import type { WorkspaceRepositoryContext } from '../../../src/cli/cli-commands/common/workspaceRepository';
 import type { number_port } from '../../../src/types/number_positive';
 import type { PriorityFilter } from '../prompts/priorityFilter';
 import type { CoderRunUiState } from '../ui/CoderRunUiState';
@@ -15,6 +16,8 @@ export type CoderHttpServerHandle = {
  * @private internal type of `ptbk coder server`
  */
 export type StartCoderHttpServerOptions = {
+    /** Project and enclosing repository resolved before server startup. */
+    readonly workspace?: WorkspaceRepositoryContext;
     readonly port: number_port;
     readonly priorityFilter: PriorityFilter;
     readonly serverUrl: string;

package/esm/scripts/run-codex-prompts/team/CoderTeamRuntime.d.ts

@@ -0,0 +1,87 @@
+import type { Usage } from '../../../src/execution/Usage';
+import type { CoderTeamAgent } from './CoderTeamAgent';
+/** An attributed tool result returned to the requesting Book, including failures. */
+export type CoderTeamResult = {
+    readonly sessionId: string;
+    readonly taskId: string;
+    readonly invocationId: string;
+    readonly callerInvocationId: string;
+    readonly teammate: {
+        readonly label: string;
+        readonly url?: string;
+        readonly toolName: string;
+    };
+    readonly request: string;
+    readonly response: string;
+    readonly error?: string;
+};
+/** Events use the existing runtime trace transport, without adding a UI or a second task queue. */
+export type CoderTeamEvent = {
+    readonly type: 'team_request' | 'team_result' | 'team_activity' | 'team_usage' | 'team_summary';
+    readonly sessionId: string;
+    readonly taskId: string;
+    readonly invocationId: string;
+    readonly callerInvocationId?: string;
+    readonly agent: string;
+    readonly data: unknown;
+};
+/** A model may invoke only tools declared by its current Book. Ancestry and permissions stay host-owned. */
+export type CoderTeamScope = {
+    readonly agent: CoderTeamAgent;
+    readonly invocationId: string;
+    readonly signal: AbortSignal;
+    readonly call: (toolName: string, argumentsValue: unknown) => Promise<CoderTeamResult>;
+    readonly activity: (data: unknown) => Promise<void>;
+};
+/** Inference receives the adviser's own Book and only the question/context selected by its caller. */
+export type CoderTeamInference = {
+    readonly scope: CoderTeamScope;
+    readonly message: string;
+    readonly context?: string;
+    /** Report each raw inference once, including successful calls followed by malformed output. */
+    readonly reportUsage: (usage: Usage) => void;
+};
+/** Shared executor contract for a coding harness or the host-mediated planning loop. */
+export type CoderTeamExecutor = (request: CoderTeamInference) => Promise<{
+    answer: string;
+    usage?: Usage;
+}>;
+/** A session-local delegation tree. No messages, answers, credentials or definitions are cached globally. */
+export declare class CoderTeamRuntime {
+    private readonly options;
+    readonly sessionId: `${string}-${string}-${string}-${string}-${string}`;
+    readonly root: CoderTeamScope;
+    private readonly controller;
+    private readonly usages;
+    private callCount;
+    private readonly pending;
+    private readonly executions;
+    private closing;
+    private isClosed;
+    private readonly cancel;
+    /** Creates a runtime but performs no adviser inference until a tool is called. */
+    constructor(options: {
+        readonly agent: CoderTeamAgent;
+        readonly taskId: string;
+        readonly execute: CoderTeamExecutor;
+        readonly signal?: AbortSignal;
+        readonly timeoutMs?: number;
+        readonly onEvent?: (event: CoderTeamEvent) => void | Promise<void>;
+    });
+    /** Adds each actual adviser inference once; nested results never include their children's usage again. */
+    get usage(): Usage;
+    /** Revokes every outstanding child when the originating task ends, fails or is cancelled. */
+    close(): Promise<void>;
+    /** Drains cancellation once; late replies cannot mutate the finished session or its trace. */
+    private closeExecutions;
+    /** Creates an immutable capability view for one position in the delegation tree. */
+    private createScope;
+    /** Validates the call before loading a Book or starting any inference. */
+    private consult;
+    /** Links cancellation and timeout to the executor, including lazy remote Book resolution and nested calls. */
+    private executeBounded;
+    /** Accounts for actual model work even when parsing or execution fails, without summing nested totals twice. */
+    private executeAgent;
+    /** Emits attribution on every trace event without passing session internals to a remote Book. */
+    private emit;
+}

package/esm/scripts/run-codex-prompts/team/coderTeamProtocol.d.ts

@@ -0,0 +1,6 @@
+import { z as schema } from 'zod';
+/** Consultation input is data; callers cannot supply credentials, policy, paths or an agent definition. */
+export declare const CODER_TEAM_ARGUMENTS_SCHEMA: schema.ZodObject<{
+    message: schema.ZodString;
+    context: schema.ZodOptional<schema.ZodString>;
+}, schema.core.$strict>;

package/esm/scripts/run-codex-prompts/team/compileCoderTeamAgent.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedLocalAgentSource } from '../../../src/cli/cli-commands/common/resolveLocalAgentSource';
+import type { CoderTeamAgent } from './CoderTeamAgent';
+/** Compiles the same TEAM schemas as Agents Server without registering process-global tool implementations. */
+export declare function compileCoderTeamAgent(source: ResolvedLocalAgentSource): Promise<CoderTeamAgent>;

package/esm/scripts/run-codex-prompts/team/createCoderTeamPromptRunner.d.ts

@@ -0,0 +1,9 @@
+import type { PromptRunner } from '../runners/types/PromptRunner';
+import { type CoderTeamEvent } from './CoderTeamRuntime';
+/**
+ * Adds a scoped consultation transport around an existing adapter. Both primary and advisers keep exactly
+ * that adapter's permissions and authentication. Only the enclosing Coder round owns tests, queues and Git operations.
+ */
+export declare function createCoderTeamPromptRunner(runner: PromptRunner, agentBookReference?: string): PromptRunner;
+/** Appends attributed machine-readable events to the existing runtime log consumed by run traces. */
+export declare function appendCoderTeamEvent(logPath: string | undefined, event: CoderTeamEvent): Promise<void>;

package/esm/scripts/run-codex-prompts/team/startCoderTeamBridge.d.ts

@@ -0,0 +1,14 @@
+import type { CoderTeamScope } from './CoderTeamRuntime';
+/** A revocable command-tool transport shared by all Coder harnesses with shell execution. */
+export type CoderTeamBridge = {
+    readonly clientPath: string;
+    readonly instructions: string;
+    readonly getAnswer: () => string;
+    readonly assertConnected: () => void;
+    readonly close: () => Promise<void>;
+};
+/**
+ * Exposes only one invocation's tools over authenticated loopback. A shell call waits for the answer and
+ * returns it on stdout as its ordinary tool result. No global harness configuration or environment is changed.
+ */
+export declare function startCoderTeamBridge(scope: CoderTeamScope, isAdviser?: boolean): Promise<CoderTeamBridge>;

package/esm/scripts/run-codex-prompts/ui/CoderRunUiState.d.ts

@@ -8,6 +8,9 @@ import type { PromptStats } from '../prompts/types/PromptStats';
 import type { HarnessSubscriptionUsage } from '../runners/types/HarnessSubscriptionUsage';
 import type { CoderRunAgentVisual } from './buildCoderRunAgentVisual';
 import type { AgentRunMessagePreviewSection, AgentRunStatusTableRow } from './buildCoderRunUiFrame';
+import type { LiveScriptOutputSource } from '../common/runGoScript/captureLiveScriptOutput';
+import type { CoderOutputMode } from './output/CoderOutputEvent';
+import { CoderRunOutput } from './output/CoderRunOutput';
 /**
  * Execution phase of the coder run process.
  *
@@ -59,6 +62,10 @@ export declare class CoderRunUiState extends EventEmitter {
     subscriptionUsage: HarnessSubscriptionUsage | undefined;
     pendingEnterLabel: string | undefined;
     agentOutputLines: string[];
+    /** Both projections share one invocation-local buffer; the selected view survives task changes. */
+    output: CoderRunOutput;
+    outputMode: CoderOutputMode;
+    outputScrollOffset: number;
     phase: CoderRunPhase;
     statusMessage: string;
     errors: string[];
@@ -117,7 +124,15 @@ export declare class CoderRunUiState extends EventEmitter {
     /**
      * Appends raw agent output text, keeping only the last `MAX_AGENT_OUTPUT_LINES`.
      */
-    addAgentOutput(text: string): void;
+    addAgentOutput(text: string, kind?: 'status' | 'warning'): void;
+    /** Receives an original harness chunk, separately from runner console messages. */
+    addScriptOutput(text: string, source: LiveScriptOutputSource): void;
+    /** Flushes final fragments without changing the selected output mode. */
+    flushOutput(): void;
+    /** Changes presentation only. Neither the queue nor any runner observes this selection. */
+    toggleOutputMode(): void;
+    /** Scrolls the bounded output history; End returns to live following. */
+    scrollOutput(lineCount: number, maximumOffset?: number): void;
     /**
      * Transitions the execution phase shown in the UI.
      */

package/esm/scripts/run-codex-prompts/ui/buildCoderRunUiFrame.d.ts

@@ -3,6 +3,8 @@ import type { CoderRunPauseState } from '../common/waitForPause';
 import type { HarnessSubscriptionUsage } from '../runners/types/HarnessSubscriptionUsage';
 import type { CoderRunConfig, CoderRunPhase, CoderRunProgressSnapshot } from './CoderRunUiState';
 import type { CoderRunAgentVisual } from './buildCoderRunAgentVisual';
+import type { CoderRunOutput } from './output/CoderRunOutput';
+import type { CoderOutputMode } from './output/CoderOutputEvent';
 /**
  * Shared pause-state shape between the renderer and the frame builder.
  */
@@ -44,6 +46,10 @@ export type BuildCoderRunUiFrameOptions = {
     readonly agentStatusTableRows?: readonly AgentRunStatusTableRow[];
     readonly pendingEnterLabel?: string;
     readonly agentOutputLines: readonly string[];
+    /** Presentation-only state; omitted by dashboards which use the older plain output panel. */
+    readonly output?: CoderRunOutput;
+    readonly outputMode?: CoderOutputMode;
+    readonly outputScrollOffset?: number;
     readonly errors: readonly string[];
     readonly progress: CoderRunProgressSnapshot;
     /**

package/esm/scripts/run-codex-prompts/ui/buildCoderRunUiViewport.d.ts

@@ -0,0 +1,5 @@
+/** Keeps controls reachable in short terminals and makes the entire existing dashboard scrollable. */
+export declare function buildCoderRunUiViewport(lines: string[], columns: number, rows: number, scrollOffset: number): {
+    lines: string[];
+    maxScrollOffset: number;
+};

package/esm/scripts/run-codex-prompts/ui/buildRunUiFrameShared.d.ts

@@ -1,6 +1,7 @@
 import type { CoderRunControlFeedbackNotice } from '../common/CoderRunControlFeedback';
 import type { CoderRunPauseState } from '../common/waitForPause';
 import type { CoderRunPhase } from './CoderRunUiState';
+import type { CoderOutputMode } from './output/CoderOutputEvent';
 /**
  * Maximum number of output lines reserved for agent output in the UI.
  */
@@ -51,7 +52,7 @@ export declare function buildTerminalUrlLink(url: string, availableWidth: number
 /**
  * Builds the colored phase badge shown in the session box.
  */
-export declare function buildPausePresentation(phase: CoderRunPhase, pauseState: CoderRunPauseState, pauseTargetLabel: string, statusMessage: string): PausePresentation;
+export declare function buildPausePresentation(phase: CoderRunPhase, pauseState: CoderRunPauseState, pauseTargetLabel: string, statusMessage: string, isBracketed?: boolean): PausePresentation;
 /**
  * Builds the progress bar shown in the session box.
  */
@@ -73,6 +74,7 @@ export declare function buildCoderRunControlPills(options: {
     readonly pendingEnterLabel: string | undefined;
     readonly isEndAfterCurrentPromptRequested: boolean;
     readonly sessionTotal: number;
+    readonly outputMode?: CoderOutputMode;
 }): readonly string[];
 /**
  * Builds the body of the `Controls` box.
@@ -83,4 +85,5 @@ export declare function buildCoderRunControlPills(options: {
 export declare function buildControlsBoxLines(options: {
     readonly controlPills: readonly string[];
     readonly controlFeedback: CoderRunControlFeedbackNotice | undefined;
+    readonly bodyWidth?: number;
 }): readonly string[];

package/esm/scripts/run-codex-prompts/ui/coderRunUiText.d.ts

@@ -28,6 +28,10 @@ export declare function fitPlainText(text: string, width: number): string;
  * @private internal utility of coder run UI
  */
 export declare function visibleLength(text: string): number;
+/** Wraps sanitized display text without splitting surrogate pairs, combining marks or emoji sequences. */
+export declare function wrapTerminalText(text: string, width: number): string[];
+/** Harness control characters may be retained in logs but cannot move the dashboard cursor. */
+export declare function sanitizeTerminalText(text: string): string;
 /**
  * Strips ANSI escape codes from a string.
  *