@promptbook/cli 0.114.0-42 → 0.114.0-48

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

@@ -0,0 +1,20 @@
+/** Display selection belongs only to this dashboard invocation. */
+export type CoderOutputMode = 'normal' | 'raw';
+/** Observable output categories; these never drive runner state. */
+export type CoderOutputKind = 'agent' | 'reasoning' | 'tool' | 'files' | 'verification' | 'result' | 'warning' | 'error' | 'status' | 'unknown';
+/** A bounded presentation entry, separate from the original harness chunks and durable trace. */
+export type CoderOutputEvent = {
+    readonly id?: string;
+    readonly kind: CoderOutputKind;
+    readonly title: string;
+    readonly text: string;
+    readonly isDelta?: boolean;
+};
+/** Permissive protocol object: all fields are checked at the presentation boundary. */
+export type CoderOutputRecord = Record<string, unknown>;
+/** Safely reads an object from an unknown protocol field. */
+export declare function outputRecord(value: unknown): CoderOutputRecord;
+/** Safely reads a string without interpreting arbitrary objects as prose. */
+export declare function outputText(value: unknown): string;
+/** Safely reads arrays containing protocol records. */
+export declare function outputRecords(value: unknown): CoderOutputRecord[];

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

@@ -0,0 +1,48 @@
+import type { LiveScriptOutputSource } from '../../common/runGoScript/captureLiveScriptOutput';
+import { type CoderOutputEvent } from './CoderOutputEvent';
+/** Original chunks in arrival order, including stream identity. */
+export type CoderRawOutputChunk = {
+    readonly text: string;
+    readonly source: string;
+};
+/** Bounded, passive projection of existing output. No method calls or controls any harness. */
+export declare class CoderRunOutput {
+    /** Lets the renderer reuse wrapping while only the spinner or elapsed timer changes. */
+    revision: number;
+    private readonly projectedEvents;
+    private readonly pendingOutput;
+    private pendingCharacterCount;
+    private skippedChunkCount;
+    readonly rawChunks: CoderRawOutputChunk[];
+    isHistoryTruncated: boolean;
+    private rawCharacterCount;
+    private sequence;
+    private generation;
+    private streams;
+    /** Makes projection lazy so input keys and process-output callbacks perform no rendering work. */
+    get events(): readonly CoderOutputEvent[];
+    /** Records the original chunk first and queues its independent presentation projection. */
+    append(chunk: string, source: LiveScriptOutputSource, harnessName: string, isVerification: boolean): void;
+    /** Projects a queued chunk, assembling stdout and stderr independently. */
+    private projectChunk;
+    /** Runner logs are already complete messages, unlike shell chunks. */
+    appendRunner(text: string, kind?: 'status' | 'warning' | 'error' | 'verification'): void;
+    /** Queues the capture boundary; runner callbacks must never perform projection or wrapping. */
+    flush(): void;
+    /** Final plain lines retain their observed speaker/activity; malformed records remain labeled as data. */
+    private flushStreams;
+    /** Pending JSON is never presented as an agent message. Plain text remains visible before a newline arrives. */
+    getPendingEvents(): CoderOutputEvent[];
+    /** Bounds deferred work too; overload is visible and durable logs remain untouched. */
+    private enqueue;
+    /** Processes bounded display work, never a runner action. */
+    private drain;
+    /** Keeps bounded original chunks separately, never replacing the durable log with normalized text. */
+    private retainRaw;
+    /** Uses the existing shared harness JSON parser; unknown and malformed records stay visible. */
+    private projectLine;
+    /** Groups adjacent lines only within the same observed activity and stream. */
+    private addPlain;
+    /** Updates known message/tool snapshots in place and suppresses duplicate result text. */
+    private add;
+}

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

@@ -0,0 +1,18 @@
+import type { CoderOutputEvent, CoderOutputMode } from './CoderOutputEvent';
+import type { CoderRawOutputChunk } from './CoderRunOutput';
+/** Reads the last rendered scroll extent without doing presentation work on the input-control path. */
+export declare function getCoderOutputScrollMaximum(chunks: readonly CoderRawOutputChunk[], mode: CoderOutputMode, height: number): number;
+/** Builds a fixed-height, wrapped viewport from the selected projection of the same stream. */
+export declare function buildCoderOutputLines(options: {
+    readonly mode: CoderOutputMode;
+    readonly events: readonly CoderOutputEvent[];
+    readonly rawChunks: readonly CoderRawOutputChunk[];
+    readonly width: number;
+    readonly height: number;
+    readonly scrollOffset: number;
+    readonly isHistoryTruncated: boolean;
+    readonly revision?: number;
+}): {
+    lines: string[];
+    maxScrollOffset: number;
+};

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

@@ -0,0 +1,10 @@
+import { type CoderOutputEvent, type CoderOutputRecord } from './CoderOutputEvent';
+/** Per-stream message identity for Claude's indexed content blocks. */
+export type CoderOutputRecordContext = {
+    messageId: string;
+    sequence: number;
+};
+/** Projects known harness envelopes into display events, without making execution decisions. */
+export declare function normalizeCoderOutputRecord(record: CoderOutputRecord, context: CoderOutputRecordContext): CoderOutputEvent[] | undefined;
+/** Displays supplied data as data, never as invented narration. */
+export declare function formatOutputValue(value: unknown): string;

package/esm/scripts/utils/emojiTags/scanEmojiTagUsage.d.ts

@@ -3,6 +3,8 @@ import type { string_char_emoji } from '../../../src/types/typeAliasEmoji';
  * Options controlling one repository emoji-tag scan.
  */
 export type EmojiTagScanOptions = {
+    /** False keeps a scan read-only while still reusing any existing cache. */
+    readonly isCacheWriteEnabled?: boolean;
     /**
      * Candidate emojis that may appear inside bracketed tags.
      */

package/esm/scripts/utils/prompts/isPromptDocumentationFile.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Reserves the prompts README for documentation, regardless of its contents or filename case.
+ * Other Markdown filenames remain valid PRDs, including names which contain the word "readme".
+ */
+export declare function isPromptDocumentationFile(filePath: string): boolean;

package/esm/scripts/utils/prompts/promptEmojiTags.d.ts

@@ -7,6 +7,8 @@ export declare const PROMPT_EMOJI_TAG_PREFIX = "\u2728";
  * Options for selecting fresh prompt emoji tags.
  */
 export type PromptEmojiTagOptions = {
+    /** Read-only authoring previews can disable the scan cache's filesystem writes. */
+    readonly isCacheWriteEnabled?: boolean;
     /**
      * Number of unique emojis to reserve.
      */

package/esm/scripts/verify-prompts/verify-prompts.d.ts

@@ -1,3 +1,4 @@
+import type { WorkspaceRepositoryContext } from '../../src/cli/cli-commands/common/workspaceRepository';
 import type { CoderGitSyncOptions } from '../run-codex-prompts/git/coderGitSync';
 import type { PromptFile } from '../run-codex-prompts/prompts/types/PromptFile';
 import type { VerifyPromptsOrder } from './VerifyPromptsOrder';
@@ -5,6 +6,8 @@ import type { VerifyPromptsOrder } from './VerifyPromptsOrder';
  * Options supported by the prompt verification helper.
  */
 export type VerifyPromptsOptions = {
+    /** Resolved project and repository supplied by the workspace preflight. */
+    readonly workspace?: WorkspaceRepositoryContext;
     /**
      * Order in which the prompt files are processed.
      */

package/esm/src/book-2.0/agent-source/CreateAgentModelRequirementsOptions.d.ts

@@ -7,6 +7,8 @@ import type { TeammateProfileResolver } from './TeammateProfileResolver';
  * @public exported from `@promptbook/core`
  */
 export type CreateAgentModelRequirementsOptions = {
+    /** A host supplying its own scoped TEAM runtime only needs the tool definitions, not global executors. */
+    readonly isTeamToolRegistrationDisabled?: boolean;
     /**
      * Resolver that transforms compact agent references (FROM, IMPORT, TEAM) into concrete URLs.
      */

package/esm/src/cli/cli-commands/coder/add.d.ts

@@ -34,3 +34,19 @@ export declare function addCoderPrompt({ projectPath, description, priority, tem
     readonly priority: number;
     readonly templateOption?: string;
 }): Promise<AddCoderPromptResult>;
+/**
+ * Prepares a numbered, emoji-tagged prompt for preview without writing the prompt file.
+ * The offset reserves consecutive identities when a planning turn proposes several files.
+ *
+ * @private internal utility shared by `coder add` and `coder plan`
+ */
+export declare function prepareCoderPrompt({ projectPath, description, priority, templateOption, numberOffset, reservedEmojiTag, }: {
+    readonly projectPath: string;
+    readonly description: string;
+    readonly priority: number;
+    readonly templateOption?: string;
+    readonly numberOffset?: number;
+    readonly reservedEmojiTag?: string;
+}): Promise<AddCoderPromptResult & {
+    readonly content: string;
+}>;

package/esm/src/cli/cli-commands/coder/agentCliOptions.d.ts

@@ -1,4 +1,5 @@
 import type { Command as Program } from 'commander';
+import { type CoderAgentRole } from './coderAgentRole';
 /**
  * Commander option bag for an optional Book agent used by coder commands.
  *
@@ -12,10 +13,10 @@ export type CoderAgentCliOptions = {
  *
  * @private internal utility of `ptbk coder`
  */
-export declare const CODER_AGENT_OPTION_DESCRIPTION = "Path to a .book file used to personalize coding prompts and select agent-specific tasks";
+export declare const CODER_AGENT_OPTION_DESCRIPTION = "Book agent providing persona, instructions, identity and task routing; --harness selects the coding tool and --model selects its model";
 /**
  * Registers the shared `--agent` option for coder commands.
  *
  * @private internal utility of `ptbk coder`
  */
-export declare function addCoderAgentOption(command: Program): void;
+export declare function addCoderAgentOption(command: Program, defaultRole?: CoderAgentRole): void;

package/esm/src/cli/cli-commands/coder/augmentCoderAgentTeam.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Adds only missing bundled TEAM commitments using canonical local Book identities.
+ * Role instructions come from the bundled Book, not from a harness or a second template here.
+ *
+ * @private internal utility of `coder init`
+ */
+export declare function augmentCoderAgentTeam(projectPath: string, role: 'developer' | 'planner'): Promise<'augmented' | 'unchanged'>;

package/esm/src/cli/cli-commands/coder/coderAgentRole.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Project-owned Book defaults for execution roles, independent of harness and model selection.
+ * Commands without an execution role, such as `coder list`, have no default Book filter.
+ *
+ * @private internal constant of `ptbk coder`
+ */
+export declare const CODER_DEFAULT_AGENT_BOOK_PATHS: {
+    readonly developer: "agents/developer.book";
+    readonly planner: "agents/planner.book";
+};
+/**
+ * Execution role whose editable local Book is selected when `--agent` is omitted.
+ *
+ * @private internal type of `ptbk coder`
+ */
+export type CoderAgentRole = keyof typeof CODER_DEFAULT_AGENT_BOOK_PATHS;

package/esm/src/cli/cli-commands/coder/coderReferencedArtifacts.d.ts

@@ -1,14 +1,14 @@
 import type { InitializationStatus } from './boilerplateTemplates';
 /**
- * Status of one artifact referenced by the default coder scripts.
+ * Status of one default Book or artifact referenced by the default coder scripts.
  *
  * `not-referenced` means that no newly added script points at the artifact, so `ptbk coder init` left it alone.
  *
  * @private internal utility of `coder init` command
  */
-export type CoderReferencedArtifactStatus = InitializationStatus | 'not-referenced';
+export type CoderReferencedArtifactStatus = InitializationStatus | 'augmented' | 'unresolved' | 'not-referenced';
 /**
- * Result of ensuring one artifact referenced by the default coder scripts.
+ * Result of ensuring one default Book or artifact referenced by the default coder scripts.
  *
  * @private internal utility of `coder init` command
  */
@@ -18,15 +18,16 @@ export type EnsuredCoderReferencedArtifact = {
      */
     readonly relativeFilePath: string;
     /**
-     * Status describing whether the artifact had to be created.
+     * Status describing whether the artifact was created, augmented, preserved, or could not be resolved.
      */
     readonly status: CoderReferencedArtifactStatus;
+    /** Explanation of an unresolved file or TEAM declaration, with the original content preserved. */
+    readonly diagnostic?: string;
 };
 /**
- * Creates only those referenced artifacts which the freshly added coder scripts point at.
+ * Initializes artifacts referenced by freshly added scripts. Default Books are ensured separately.
  *
- * An artifact of a script which the project already defines is intentionally **not** created - the project-owned
- * script is kept as is, so it does not reference the default artifact in the first place.
+ * For artifacts other than role Books, an existing project script does not cause default files to be created.
  *
  * @private function of `initializeCoderProjectConfiguration`
  */

package/esm/src/cli/cli-commands/coder/ensureCoderDefaultAgentFiles.d.ts

@@ -0,0 +1,8 @@
+import type { EnsuredCoderReferencedArtifact } from './coderReferencedArtifacts';
+/**
+ * Ensures every default Book independently, then adds missing helper declarations to the two primary roles.
+ * A failure leaves the affected Book intact and does not prevent the remaining files from being initialized.
+ *
+ * @private internal utility of `coder init`
+ */
+export declare function ensureCoderDefaultAgentFiles(projectPath: string): Promise<EnsuredCoderReferencedArtifact[]>;

package/esm/src/cli/cli-commands/coder/ensureCoderDefaultAgentFiles.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/src/cli/cli-commands/coder/ensureCoderRoleAgentFile.d.ts

@@ -0,0 +1,12 @@
+import type { InitializationStatus } from './boilerplateTemplates';
+/**
+ * Project-owned planning role selected when `coder plan` has no explicit Book override.
+ * @private internal constant of Coder role resolution
+ */
+export declare const CODER_PLANNER_AGENT_FILE_PATH = "agents/planner.book";
+/**
+ * Copies a bundled role without overwriting an existing project-owned Book, including on repeated init.
+ *
+ * @private internal utility of `coder init`
+ */
+export declare function ensureCoderRoleAgentFile(projectPath: string, role: 'developer' | 'planner' | 'lawyer' | 'copywriter'): Promise<InitializationStatus>;

package/esm/src/cli/cli-commands/coder/generate-boilerplates.d.ts

@@ -18,4 +18,4 @@ export declare function generatePromptBoilerplate({ projectPath, boilerplateCoun
     readonly projectPath: string;
     readonly boilerplateCount: BoilerplateCount;
     readonly templateOption?: string;
-}): Promise<void>;
+}): Promise<ReadonlyArray<string>>;

package/esm/src/cli/cli-commands/coder/getCoderInitializationCommitPaths.d.ts

@@ -0,0 +1,9 @@
+import type { WorkspaceRepositoryContext } from '../common/workspaceRepository';
+import type { CoderInitializationSummary } from './initializeCoderProjectConfiguration';
+/**
+ * Restricts an explicit initialization commit to the initializer's write set, in repository-relative paths.
+ * The shared snapshot still excludes pre-existing files that initialization did not actually change.
+ *
+ * @private internal utility of the shared project initializer
+ */
+export declare function getCoderInitializationCommitPaths(workspace: WorkspaceRepositoryContext, summary: CoderInitializationSummary, boilerplatePaths: ReadonlyArray<string>): ReadonlyArray<string>;

package/esm/src/cli/cli-commands/coder/initializeCoderProjectConfiguration.d.ts

@@ -1,5 +1,5 @@
 import type { InitializationStatus } from './boilerplateTemplates';
-import type { EnsuredCoderReferencedArtifact } from './coderReferencedArtifacts';
+import type { CoderReferencedArtifactStatus, EnsuredCoderReferencedArtifact } from './coderReferencedArtifacts';
 /**
  * Result summary returned after coder configuration initialization.
  *
@@ -7,10 +7,12 @@ import type { EnsuredCoderReferencedArtifact } from './coderReferencedArtifacts'
  */
 export type CoderInitializationSummary = {
     readonly promptsDirectoryStatus: InitializationStatus;
+    readonly promptsReadmeFileStatus: InitializationStatus;
     readonly promptsDoneDirectoryStatus: InitializationStatus;
     readonly promptsTemplatesDirectoryStatus: InitializationStatus;
     readonly agentsDirectoryStatus: InitializationStatus;
-    readonly adamAgentFileStatus: InitializationStatus;
+    readonly adamAgentFileStatus: CoderReferencedArtifactStatus;
+    readonly adamAgentFileDiagnostic?: string;
     readonly envFileStatus: InitializationStatus;
     readonly gitignoreFileStatus: InitializationStatus;
     readonly packageJsonFileStatus: InitializationStatus;
@@ -22,9 +24,9 @@ export type CoderInitializationSummary = {
 /**
  * Creates or updates all coder configuration artifacts required in the current project.
  *
- * Nothing the project already owns is ever overwritten - existing scripts, settings and files are kept as they are,
- * and the artifacts they would reference are created only together with the scripts which actually reference them.
+ * Existing scripts, settings and Books are preserved. Missing Books and helper TEAM declarations are added
+ * independently of package scripts, with unresolved artifacts reported without replacing project content.
  *
  * @private internal utility of `coder init` command
  */
-export declare function initializeCoderProjectConfiguration(projectPath: string): Promise<CoderInitializationSummary>;
+export declare function initializeCoderProjectConfiguration(projectPath: string, onStepCompleted?: (step: string) => void): Promise<CoderInitializationSummary>;

package/esm/src/cli/cli-commands/coder/plan.d.ts

@@ -0,0 +1,7 @@
+import type { Command as Program } from 'commander';
+import type { $side_effect } from '../../../utils/organization/$side_effect';
+/**
+ * Registers the repository-aware, planning-only conversation under the existing coder command group.
+ * @private internal utility of `promptbookCli`
+ */
+export declare function $initializeCoderPlanCommand(program: Program): $side_effect;

package/esm/src/cli/cli-commands/coder/planning/assertPlanningCommitSafe.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Protects the shared authoring Git helper's temporary directory and shell-quoted absolute message path.
+ * PRD paths themselves are checked separately by the write boundary before every save and commit.
+ * @private internal execution boundary of `coder plan`
+ */
+export declare function assertPlanningCommitSafe(projectPath: string): void;

package/esm/src/cli/cli-commands/coder/planning/assertPlanningPrdCommitScope.d.ts

@@ -0,0 +1,7 @@
+import type { PlanningChange } from './preparePlanningChanges';
+/**
+ * Refuses to mix prior or concurrent user edits into a PRD that this session intends to commit.
+ * After the first save, the session's exact saved text is the baseline for subsequent revisions.
+ * @private internal execution boundary of `coder plan`
+ */
+export declare function assertPlanningPrdCommitScope(projectPath: string, changes: ReadonlyArray<PlanningChange>, savedContents: ReadonlyMap<string, string>, preexistingChangedPaths: ReadonlySet<string>): Promise<void>;

package/esm/src/cli/cli-commands/coder/planning/assertPlanningRuntimePath.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Keeps host-owned staging and Git runtime directories inside the ordinary Promptbook temporary tree.
+ * Missing directories are allowed, but no existing ancestor may redirect subsequent writes through a link.
+ * @private internal execution boundary of `coder plan`
+ */
+export declare function assertPlanningRuntimePath(projectPath: string, runtimePath: string): void;

package/esm/src/cli/cli-commands/coder/planning/createPlanningTerminal.d.ts

@@ -0,0 +1,8 @@
+import type { PlanningSessionIo } from './runPlanningSession';
+/**
+ * Builds an EOF-aware terminal. EOF or Ctrl+C also cancels an in-flight harness turn.
+ * @private internal utility of `coder plan`
+ */
+export declare function createPlanningTerminal(): PlanningSessionIo & {
+    readonly close: () => void;
+};

package/esm/src/cli/cli-commands/coder/planning/createPlanningTerminal.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/src/cli/cli-commands/coder/planning/createPlanningWorkspace.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Host-owned structured output contract kept outside the PRD queue.
+ * @private internal constant of `coder plan`
+ */
+export declare const PLANNING_RESPONSE_SCHEMA_FILENAME = "response.schema.json";
+/**
+ * Creates isolated runtime state in the already ignored Promptbook location, outside the PRD queue.
+ * An empty Git root prevents the harness from loading repository-local configuration and hooks.
+ * @private internal utility of `coder plan`
+ */
+export declare function createPlanningWorkspace(projectPath: string): Promise<string>;

package/esm/src/cli/cli-commands/coder/planning/discussPlanningTurn.d.ts

@@ -0,0 +1,15 @@
+import type { CoderTeamScope } from '../../../../../scripts/run-codex-prompts/team/CoderTeamRuntime';
+import { type PlanningMessage, type PlanningReply } from './planningProtocol';
+/**
+ * Runs the same read-only protocol throughout the delegation tree. Only the primary caller can receive proposals.
+ * @private internal utility of `coder plan`
+ */
+export declare function discussPlanningTurn(options: {
+    readonly projectPath: string;
+    readonly history: PlanningMessage[];
+    readonly signal: AbortSignal;
+    readonly infer: () => Promise<string>;
+    readonly team?: CoderTeamScope;
+    readonly isAdviser?: boolean;
+    readonly write?: (message: string) => void;
+}): Promise<PlanningReply>;

package/esm/src/cli/cli-commands/coder/planning/fixtures/snapshotPlanningProject.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Captures project-owned fixture files while excluding the ignored planning runtime and linked test targets.
+ * @private test utility of `coder plan`
+ */
+export declare function snapshotPlanningProject(projectPath: string, directory?: string): Promise<Record<string, string>>;

package/esm/src/cli/cli-commands/coder/planning/planningGitSync.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/src/cli/cli-commands/coder/planning/planningPackagedCli.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/src/cli/cli-commands/coder/planning/planningProtocol.d.ts

@@ -0,0 +1,152 @@
+import { z as schema } from 'zod';
+/** Read-only host requests and scoped TEAM consultations; there is deliberately no shell operation. */
+declare const PLANNING_READ_SCHEMA: schema.ZodDiscriminatedUnion<[schema.ZodObject<{
+    kind: schema.ZodLiteral<"list">;
+    path: schema.ZodString;
+}, schema.core.$strict>, schema.ZodObject<{
+    kind: schema.ZodLiteral<"read">;
+    path: schema.ZodString;
+    startLine: schema.ZodNumber;
+    lineCount: schema.ZodNumber;
+}, schema.core.$strict>, schema.ZodObject<{
+    kind: schema.ZodLiteral<"search">;
+    path: schema.ZodString;
+    query: schema.ZodString;
+}, schema.core.$strict>, schema.ZodObject<{
+    kind: schema.ZodLiteral<"git">;
+    operation: schema.ZodEnum<{
+        status: "status";
+        diff: "diff";
+        log: "log";
+    }>;
+}, schema.core.$strict>, schema.ZodObject<{
+    message: schema.ZodString;
+    context: schema.ZodNonOptional<schema.ZodOptional<schema.ZodString>>;
+    kind: schema.ZodLiteral<"team">;
+    toolName: schema.ZodString;
+}, schema.core.$strict>], "kind">;
+/** Proposed changes are data, never instructions executed by a harness. */
+declare const PLANNING_PROPOSAL_SCHEMA: schema.ZodDiscriminatedUnion<[schema.ZodObject<{
+    kind: schema.ZodLiteral<"create">;
+    title: schema.ZodString;
+    body: schema.ZodString;
+    priority: schema.ZodNumber;
+    isReady: schema.ZodBoolean;
+}, schema.core.$strict>, schema.ZodObject<{
+    kind: schema.ZodLiteral<"edit">;
+    path: schema.ZodString;
+    find: schema.ZodString;
+    replace: schema.ZodString;
+    isReady: schema.ZodBoolean;
+}, schema.core.$strict>], "kind">;
+/** Strict validation prevents unsupported operations from reaching any filesystem code. */
+declare const PLANNING_REPLY_SCHEMA: schema.ZodObject<{
+    message: schema.ZodString;
+    reads: schema.ZodArray<schema.ZodDiscriminatedUnion<[schema.ZodObject<{
+        kind: schema.ZodLiteral<"list">;
+        path: schema.ZodString;
+    }, schema.core.$strict>, schema.ZodObject<{
+        kind: schema.ZodLiteral<"read">;
+        path: schema.ZodString;
+        startLine: schema.ZodNumber;
+        lineCount: schema.ZodNumber;
+    }, schema.core.$strict>, schema.ZodObject<{
+        kind: schema.ZodLiteral<"search">;
+        path: schema.ZodString;
+        query: schema.ZodString;
+    }, schema.core.$strict>, schema.ZodObject<{
+        kind: schema.ZodLiteral<"git">;
+        operation: schema.ZodEnum<{
+            status: "status";
+            diff: "diff";
+            log: "log";
+        }>;
+    }, schema.core.$strict>, schema.ZodObject<{
+        message: schema.ZodString;
+        context: schema.ZodNonOptional<schema.ZodOptional<schema.ZodString>>;
+        kind: schema.ZodLiteral<"team">;
+        toolName: schema.ZodString;
+    }, schema.core.$strict>], "kind">>;
+    proposals: schema.ZodArray<schema.ZodDiscriminatedUnion<[schema.ZodObject<{
+        kind: schema.ZodLiteral<"create">;
+        title: schema.ZodString;
+        body: schema.ZodString;
+        priority: schema.ZodNumber;
+        isReady: schema.ZodBoolean;
+    }, schema.core.$strict>, schema.ZodObject<{
+        kind: schema.ZodLiteral<"edit">;
+        path: schema.ZodString;
+        find: schema.ZodString;
+        replace: schema.ZodString;
+        isReady: schema.ZodBoolean;
+    }, schema.core.$strict>], "kind">>;
+}, schema.core.$strict>;
+/**
+ * The same response contract constrains Codex output and validates it at the host boundary.
+ * @private internal constant of `coder plan`
+ */
+export declare const PLANNING_RESPONSE_SCHEMA: schema.core.ZodStandardJSONSchemaPayload<schema.ZodObject<{
+    message: schema.ZodString;
+    reads: schema.ZodArray<schema.ZodDiscriminatedUnion<[schema.ZodObject<{
+        kind: schema.ZodLiteral<"list">;
+        path: schema.ZodString;
+    }, schema.core.$strict>, schema.ZodObject<{
+        kind: schema.ZodLiteral<"read">;
+        path: schema.ZodString;
+        startLine: schema.ZodNumber;
+        lineCount: schema.ZodNumber;
+    }, schema.core.$strict>, schema.ZodObject<{
+        kind: schema.ZodLiteral<"search">;
+        path: schema.ZodString;
+        query: schema.ZodString;
+    }, schema.core.$strict>, schema.ZodObject<{
+        kind: schema.ZodLiteral<"git">;
+        operation: schema.ZodEnum<{
+            status: "status";
+            diff: "diff";
+            log: "log";
+        }>;
+    }, schema.core.$strict>, schema.ZodObject<{
+        message: schema.ZodString;
+        context: schema.ZodNonOptional<schema.ZodOptional<schema.ZodString>>;
+        kind: schema.ZodLiteral<"team">;
+        toolName: schema.ZodString;
+    }, schema.core.$strict>], "kind">>;
+    proposals: schema.ZodArray<schema.ZodDiscriminatedUnion<[schema.ZodObject<{
+        kind: schema.ZodLiteral<"create">;
+        title: schema.ZodString;
+        body: schema.ZodString;
+        priority: schema.ZodNumber;
+        isReady: schema.ZodBoolean;
+    }, schema.core.$strict>, schema.ZodObject<{
+        kind: schema.ZodLiteral<"edit">;
+        path: schema.ZodString;
+        find: schema.ZodString;
+        replace: schema.ZodString;
+        isReady: schema.ZodBoolean;
+    }, schema.core.$strict>], "kind">>;
+}, schema.core.$strict>>;
+/** @private internal type of `coder plan` */
+export type PlanningRead = Exclude<schema.infer<typeof PLANNING_READ_SCHEMA>, {
+    kind: 'team';
+}>;
+/** @private internal type of `coder plan` */
+export type PlanningProposal = schema.infer<typeof PLANNING_PROPOSAL_SCHEMA>;
+/** @private internal type of `coder plan` */
+export type PlanningReply = schema.infer<typeof PLANNING_REPLY_SCHEMA>;
+/** @private internal type of `coder plan` */
+export type PlanningMessage = {
+    readonly role: 'user' | 'planner' | 'context';
+    readonly content: string;
+};
+/**
+ * Rejects malformed or unsupported harness output before processing reads or proposed writes.
+ * @private internal utility of `coder plan`
+ */
+export declare function parsePlanningReply(output: string): PlanningReply;
+/**
+ * Describes the host-mediated planning protocol, independent of the selected Book's instructions.
+ * @private internal constant of `coder plan`
+ */
+export declare const PLANNING_PROTOCOL: string;
+export {};

package/esm/src/cli/cli-commands/coder/planning/planningTeam.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/src/cli/cli-commands/coder/planning/preparePlanningChanges.d.ts

@@ -0,0 +1,16 @@
+import type { PlanningProposal } from './planningProtocol';
+/**
+ * A fully rendered change retained in memory until the user explicitly saves it.
+ * @private internal type of `coder plan`
+ */
+export type PlanningChange = {
+    readonly path: string;
+    readonly before: string | null;
+    readonly after: string;
+    readonly draft: string;
+};
+/**
+ * Prepares an entire proposal set without writing. Exact replacements preserve unrelated content and line endings.
+ * @private internal utility of `coder plan`
+ */
+export declare function preparePlanningChanges(projectPath: string, proposals: ReadonlyArray<PlanningProposal>, templateOption: string | undefined): Promise<PlanningChange[]>;

package/esm/src/cli/cli-commands/coder/planning/readPlanningContext.d.ts

@@ -0,0 +1,6 @@
+import type { PlanningRead } from './planningProtocol';
+/**
+ * Executes only the read operations in the planning protocol. Never evaluates a command from the model.
+ * @private internal utility of `coder plan`
+ */
+export declare function readPlanningContext(projectPath: string, request: PlanningRead): Promise<string>;

package/esm/src/cli/cli-commands/coder/planning/resolvePlanningPath.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Resolves a repository path without traversing symlinks, junctions, device paths, or parent escapes.
+ * Writes additionally require an ordinary, singly linked PRD Markdown file in the active prompts directory.
+ * The queue loader reads only this directory; archives, templates and reusable context remain read-only.
+ * @private internal execution boundary of `coder plan`
+ */
+export declare function resolvePlanningPath(projectPath: string, path: string, isWriting?: boolean): string;