@promptbook/cli 0.114.0-5 → 0.114.0-50

package/umd/src/cli/cli-commands/coder/ensureCoderGitattributesFile.d.ts

@@ -0,0 +1,13 @@
+import type { InitializationStatus } from './boilerplateTemplates';
+/**
+ * Project-relative path to the Git attributes initialized by Promptbook Coder.
+ *
+ * @private internal constant of `coder init`
+ */
+export declare const CODER_GITATTRIBUTES_FILE_PATH = ".gitattributes";
+/**
+ * Creates default Git attributes when missing, preserving project-owned attributes.
+ *
+ * @private function of `initializeCoderProjectConfiguration`
+ */
+export declare function ensureCoderGitattributesFile(projectPath: string): Promise<InitializationStatus>;

package/umd/src/cli/cli-commands/coder/ensureCoderGitignoreFile.d.ts

@@ -1,7 +1,20 @@
+import { type PromptRunnerHarnessName } from '../common/promptRunnerCliOptions';
 import type { InitializationStatus } from './boilerplateTemplates';
 /**
- * Ensures `.gitignore` contains the standalone Promptbook temp entry.
+ * Ensures `.gitignore` covers local dependencies, coder artifacts and every supported harness's local artifacts.
  *
  * @private function of `initializeCoderProjectConfiguration`
  */
 export declare function ensureCoderGitignoreFile(projectPath: string): Promise<InitializationStatus>;
+/**
+ * Lists missing project-local ignore rules for the selected harnesses.
+ *
+ * @private internal utility of `ptbk coder`
+ */
+export declare function getMissingCoderHarnessGitignoreRules(projectPath: string, harnessNames: ReadonlyArray<PromptRunnerHarnessName>): Promise<ReadonlyArray<string>>;
+/**
+ * Adds the given Promptbook Coder rules to a project's `.gitignore` file.
+ *
+ * @private internal utility of `ptbk coder`
+ */
+export declare function ensureCoderGitignoreRules(projectPath: string, rules: ReadonlyArray<string>): Promise<InitializationStatus>;

package/umd/src/cli/cli-commands/coder/ensureCoderPackageJsonFile.d.ts

@@ -1,7 +1,10 @@
-import type { InitializationStatus } from './boilerplateTemplates';
+import type { MergedStringRecordJsonFile } from './mergeStringRecordJsonFile';
+import { type PreparedCoderPackageJsonScripts } from './prepareCoderPackageJsonScripts';
 /**
  * Ensures `package.json` contains the standalone Promptbook coder helper scripts.
  *
+ * Project definitions are preserved; missing scripts and narrowly recognized generated migrations are applied.
+ *
  * @private function of `initializeCoderProjectConfiguration`
  */
-export declare function ensureCoderPackageJsonFile(projectPath: string): Promise<InitializationStatus>;
+export declare function ensureCoderPackageJsonFile(projectPath: string): Promise<MergedStringRecordJsonFile & Omit<PreparedCoderPackageJsonScripts, 'scripts'>>;

package/umd/src/cli/cli-commands/coder/ensureCoderPackageJsonFile.test.d.ts

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

package/umd/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/umd/src/cli/cli-commands/coder/ensureCoderVscodeSettingsFile.d.ts

@@ -2,6 +2,8 @@ import type { InitializationStatus } from './boilerplateTemplates';
 /**
  * Ensures VS Code routes pasted prompt images into `prompts/screenshots`.
  *
+ * Settings which the project already defines are kept as they are, only missing ones are added.
+ *
  * @private function of `initializeCoderProjectConfiguration`
  */
 export declare function ensureCoderVscodeSettingsFile(projectPath: string): Promise<InitializationStatus>;

package/umd/src/cli/cli-commands/coder/ensureDirectory.d.ts

@@ -5,3 +5,9 @@ import type { InitializationStatus } from './boilerplateTemplates';
  * @private function of `initializeCoderProjectConfiguration`
  */
 export declare function ensureDirectory(projectPath: string, relativeDirectoryPath: string): Promise<InitializationStatus>;
+/**
+ * Checks whether a project-relative directory is missing or contains no entries.
+ *
+ * @private internal utility of `coder init` command
+ */
+export declare function isDirectoryEmpty(projectPath: string, relativeDirectoryPath: string): Promise<boolean>;

package/umd/src/cli/cli-commands/coder/findLegacyCoderCheckCallers.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Finds external project callers conservatively; it never rewrites their shell expressions.
+ * @private migration safety check for the Coder initializer
+ */
+export declare function findLegacyCoderCheckCallers(projectPath: string, legacyNames: ReadonlyArray<string>): Promise<Readonly<Record<string, ReadonlyArray<string>>>>;

package/umd/src/cli/cli-commands/coder/fix.d.ts

@@ -0,0 +1,7 @@
+import type { Command as Program } from 'commander';
+import type { $side_effect } from '../../../utils/organization/$side_effect';
+/**
+ * Registers a finite check-repair command with the shared parser, defaults and execution policy.
+ * @private internal CLI command registration
+ */
+export declare function $initializeCoderFixCommand(program: Program): $side_effect;

package/umd/src/cli/cli-commands/coder/fix.test.d.ts

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

package/umd/src/cli/cli-commands/coder/fixWorkflow.test.d.ts

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

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

@@ -10,7 +10,7 @@ import type { BoilerplateCount } from './boilerplateCount';
  */
 export declare function $initializeCoderGenerateBoilerplatesCommand(program: Program): $side_effect;
 /**
- * Generates boilerplate prompt files with unique emoji tags.
+ * Generates boilerplate prompt files with one unique emoji tag per file.
  *
  * @private internal function of `generatePromptBoilerplate` command
  */
@@ -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/umd/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/umd/src/cli/cli-commands/coder/getDefaultCoderPackageJsonScripts.d.ts

@@ -4,3 +4,9 @@
  * @private internal utility of `coder init` command
  */
 export declare function getDefaultCoderPackageJsonScripts(): Readonly<Record<string, string>>;
+/**
+ * Collects the project-relative artifact paths referenced by the given default coder scripts.
+ *
+ * @private internal utility of `coder init` command
+ */
+export declare function resolveCoderPackageJsonScriptReferencedArtifactPaths(scriptNames: ReadonlyArray<string>): ReadonlySet<string>;

package/umd/src/cli/cli-commands/coder/init.test.d.ts

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

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

@@ -1,4 +1,5 @@
-import type { EnsuredCoderPromptTemplateFile, InitializationStatus } from './boilerplateTemplates';
+import type { InitializationStatus } from './boilerplateTemplates';
+import type { CoderReferencedArtifactStatus, EnsuredCoderReferencedArtifact } from './coderReferencedArtifacts';
 /**
  * Result summary returned after coder configuration initialization.
  *
@@ -6,22 +7,33 @@ import type { EnsuredCoderPromptTemplateFile, InitializationStatus } from './boi
  */
 export type CoderInitializationSummary = {
     readonly promptsDirectoryStatus: InitializationStatus;
+    readonly promptsReadmeFileStatus: InitializationStatus;
     readonly promptsDoneDirectoryStatus: InitializationStatus;
     readonly promptsTemplatesDirectoryStatus: InitializationStatus;
-    readonly promptTemplateFileStatuses: ReadonlyArray<EnsuredCoderPromptTemplateFile>;
     readonly agentsDirectoryStatus: InitializationStatus;
-    readonly developerAgentFileStatus: InitializationStatus;
-    readonly agentsFileStatus: InitializationStatus;
-    readonly agentCodingFileStatus: InitializationStatus;
+    readonly adamAgentFileStatus: CoderReferencedArtifactStatus;
+    readonly adamAgentFileDiagnostic?: string;
     readonly envFileStatus: InitializationStatus;
     readonly gitignoreFileStatus: InitializationStatus;
+    readonly gitattributesFileStatus: InitializationStatus;
     readonly packageJsonFileStatus: InitializationStatus;
     readonly vscodeSettingsFileStatus: InitializationStatus;
+    readonly addedPackageJsonScriptNames: ReadonlyArray<string>;
+    readonly referencedArtifactStatuses: ReadonlyArray<EnsuredCoderReferencedArtifact>;
     readonly initializedEnvVariableNames: ReadonlyArray<string>;
+    /** Actual preserved or generated scope of the project check. */
+    readonly checkScriptSummary: string;
+    /** Manual steps needed for custom or conflicting legacy entries. */
+    readonly migrationInstructions: ReadonlyArray<string>;
+    /** Whether validation is configured rather than still requiring setup. */
+    readonly isCheckConfigured: boolean;
 };
 /**
  * Creates or updates all coder configuration artifacts required in the current project.
  *
+ * 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/umd/src/cli/cli-commands/coder/list.d.ts

@@ -0,0 +1,10 @@
+import type { Command as Program } from 'commander';
+import type { $side_effect } from '../../../utils/organization/$side_effect';
+/**
+ * Initializes `coder list` command for Promptbook CLI utilities.
+ *
+ * Note: `$` is used to indicate that this function is not a pure function - it registers a command in the CLI.
+ *
+ * @private internal function of `promptbookCli`
+ */
+export declare function $initializeCoderListCommand(program: Program): $side_effect;

package/umd/src/cli/cli-commands/coder/list.test.d.ts

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

package/umd/src/cli/cli-commands/coder/mergeStringRecordJsonFile.d.ts

@@ -8,11 +8,31 @@ type MergeStringRecordJsonFileOptions = {
     readonly fieldPath: string;
     readonly nextEntries: Readonly<Record<string, string>>;
     readonly ensureParentDirectoryPath?: string;
+    /** Optional narrowly scoped migration of existing entries before missing defaults are added. */
+    readonly transformExistingEntries?: (entries: Readonly<Record<string, string>>) => Readonly<Record<string, string>> | Promise<Readonly<Record<string, string>>>;
+};
+/**
+ * Result of one additive string-record merge into a JSON file.
+ *
+ * @private internal utility of `coder init` command
+ */
+export type MergedStringRecordJsonFile = {
+    /**
+     * Status describing whether the JSON file had to be created or updated.
+     */
+    readonly status: InitializationStatus;
+    /**
+     * Keys which were missing in the JSON file and therefore added by the merge.
+     */
+    readonly addedEntryKeys: ReadonlyArray<string>;
 };
 /**
  * Ensures one JSON object field contains the provided string-record entries.
  *
+ * Entries are additive unless a caller explicitly supplies a scoped migration callback.
+ * Hand-tuned scripts and settings survive repeated `ptbk coder init`; migrations recognize generated entries only.
+ *
  * @private function of `initializeCoderProjectConfiguration`
  */
-export declare function mergeStringRecordJsonFile({ projectPath, relativeFilePath, fieldPath, nextEntries, ensureParentDirectoryPath, }: MergeStringRecordJsonFileOptions): Promise<InitializationStatus>;
+export declare function mergeStringRecordJsonFile({ projectPath, relativeFilePath, fieldPath, nextEntries, ensureParentDirectoryPath, transformExistingEntries, }: MergeStringRecordJsonFileOptions): Promise<MergedStringRecordJsonFile>;
 export {};

package/umd/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/umd/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/umd/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/umd/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/umd/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/umd/src/cli/cli-commands/coder/planning/createPlanningTerminal.test.d.ts

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

package/umd/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/umd/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/umd/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/umd/src/cli/cli-commands/coder/planning/planningGitSync.test.d.ts

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

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

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

package/umd/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/umd/src/cli/cli-commands/coder/planning/planningTeam.test.d.ts

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

package/umd/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/umd/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/umd/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;

package/umd/src/cli/cli-commands/coder/planning/runPlanningHarness.d.ts

@@ -0,0 +1,30 @@
+import type { Usage } from '../../../../execution/Usage';
+import type { NormalizedPromptRunnerSelectionCliOptions } from '../../common/promptRunnerCliOptions';
+/**
+ * Parameters for one tool-restricted inference. Repository reads and PRD writes are host operations.
+ * @private internal type of `coder plan`
+ */
+export type PlanningHarnessOptions = NormalizedPromptRunnerSelectionCliOptions & {
+    readonly workspacePath: string;
+    readonly prompt: string;
+    readonly signal: AbortSignal;
+    /** Reports available usage from this inference once, including turns whose final answer is malformed. */
+    readonly onUsage?: (usage: Usage) => void;
+};
+/**
+ * Rejects harnesses without a planning execution policy before any Git sync or process launch.
+ * @private internal utility of `coder plan`
+ */
+export declare function assertPlanningHarnessSupported(harness: string | undefined): void;
+/**
+ * Constructs a fail-closed Codex invocation. User config, rules, project config discovery, native shell,
+ * connectors, hooks and delegation cannot expand the planning tool set. Read-only sandboxing also denies patches.
+ * Older Codex versions that do not support these switches fail instead of using the implementation runner.
+ * @private internal utility of `coder plan`
+ */
+export declare function buildPlanningHarnessArguments(options: PlanningHarnessOptions): string[];
+/**
+ * Runs a bounded inference with no shell interpolation and consumes only its final JSON answer.
+ * @private internal utility of `coder plan`
+ */
+export declare function runPlanningHarness(options: PlanningHarnessOptions): Promise<string>;

package/umd/src/cli/cli-commands/coder/planning/runPlanningHarness.test.d.ts

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

package/umd/src/cli/cli-commands/coder/planning/runPlanningSession.d.ts

@@ -0,0 +1,24 @@
+import { type ResolvedCoderProjectContext } from '../../../../../scripts/run-codex-prompts/common/resolveCoderProjectContext';
+import type { NormalizedPromptRunnerSelectionCliOptions } from '../../common/promptRunnerCliOptions';
+import { runPlanningHarness } from './runPlanningHarness';
+/**
+ * Terminal interface also used by deterministic conversation fixtures.
+ * @private internal type of `coder plan`
+ */
+export type PlanningSessionIo = {
+    readonly readMessage: () => Promise<string | undefined>;
+    readonly write: (message: string) => void;
+    readonly signal: AbortSignal;
+};
+/**
+ * Runs one multi-topic planning conversation; only explicit save commands cross the PRD write boundary.
+ * @private internal utility of `coder plan`
+ */
+export declare function runPlanningSession(options: NormalizedPromptRunnerSelectionCliOptions & {
+    readonly projectPath: string;
+    readonly agent?: string;
+    readonly context?: string;
+    readonly projectContext?: ResolvedCoderProjectContext;
+    readonly template?: string;
+    readonly preexistingChangedPaths?: ReadonlySet<string>;
+}, io: PlanningSessionIo, harness?: typeof runPlanningHarness): Promise<ReadonlyMap<string, string>>;

package/umd/src/cli/cli-commands/coder/planning/runPlanningSession.test.d.ts

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

package/umd/src/cli/cli-commands/coder/planning/savePlanningChanges.d.ts

@@ -0,0 +1,7 @@
+import type { PlanningChange } from './preparePlanningChanges';
+/**
+ * Validates the entire batch before writing, stages outside the queue, then atomically replaces each file.
+ * The synchronous commit region cannot be interrupted by a SIGINT callback halfway through a save.
+ * @private internal execution boundary of `coder plan`
+ */
+export declare function savePlanningChanges(projectPath: string, workspacePath: string, changes: ReadonlyArray<PlanningChange>, isDraft: boolean): string[];

package/umd/src/cli/cli-commands/coder/prepareCoderPackageJsonScripts.d.ts

@@ -0,0 +1,12 @@
+/** Result of preparing project-owned checks and migrating recognized generated callers. @private internal initializer result */
+export type PreparedCoderPackageJsonScripts = {
+    readonly scripts: Readonly<Record<string, string>>;
+    readonly checkScriptSummary: string;
+    readonly migrationInstructions: ReadonlyArray<string>;
+    readonly isCheckConfigured: boolean;
+};
+/**
+ * Preserves project scripts, creates one canonical check, and migrates only exact generated caller forms.
+ * @private shared package-script preparation for Coder initialization
+ */
+export declare function prepareCoderPackageJsonScripts(existing: Readonly<Record<string, string>>, externalCallers?: Readonly<Record<string, ReadonlyArray<string>>>): PreparedCoderPackageJsonScripts;

package/umd/src/cli/cli-commands/coder/printCoderRunFailure.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Prints why a coder run has ended to the terminal.
+ *
+ * @private internal utility of `coder run` and `coder server` commands
+ */
+export declare function printCoderRunFailure(error: Error): void;

package/umd/src/cli/cli-commands/coder/printInitializationSummary.d.ts

@@ -1,7 +1,8 @@
+import type { WorkspaceRepositoryContext } from '../common/workspaceRepository';
 import type { CoderInitializationSummary } from './initializeCoderProjectConfiguration';
 /**
  * Prints a readable summary of what was initialized for the user.
  *
  * @private function of `coder init` command
  */
-export declare function printInitializationSummary(summary: CoderInitializationSummary): void;
+export declare function printInitializationSummary(summary: CoderInitializationSummary, workspace?: WorkspaceRepositoryContext): void;