@promptbook/cli 0.114.0-49 → 0.114.0-50

package/umd/scripts/run-codex-prompts/git/quoteGitArgument.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Quotes one literal Git argument for its selected shell. Finite jobs use the shared Bash process-tree runner
+ * on every platform; legacy Windows callers use their existing native command shell.
+ */
+export declare function quoteGitArgument(value: string, isBashShell?: boolean): string;

package/umd/scripts/run-codex-prompts/git/runGitCommand.d.ts

@@ -6,6 +6,10 @@ type RunGitCommandOptions = {
     readonly cwd?: string;
     readonly env?: Record<string, string>;
     readonly isVerbose?: boolean;
+    /** A finite job cancels the same owned shell tree as its checks and harness. */
+    readonly signal?: AbortSignal;
+    /** Phase persistence must not retry a hook which may already have created a local commit. */
+    readonly isIndexLockRetryEnabled?: boolean;
 };
 /**
  * Runs one Git command and retries when the repository index is still temporarily locked.

package/umd/scripts/run-codex-prompts/git/runWorkspaceGitWithIndexReadRetry.d.ts

@@ -0,0 +1,7 @@
+import { $runWorkspaceGit } from '../../../src/cli/cli-commands/common/workspaceRepository';
+/**
+ * Uses the shared Git service, retrying only a Windows index-open permission failure during a read-only inspection.
+ * Persistent access errors and every mutation still fail normally. Snapshot callers retain their before/after
+ * comparisons, so a retry cannot publish content which changed during capture.
+ */
+export declare function runWorkspaceGitWithIndexReadRetry(projectPath: string, argumentsList: ReadonlyArray<string>, options?: Parameters<typeof $runWorkspaceGit>[2]): Promise<string>;

package/umd/scripts/run-codex-prompts/git/workingTreeChanges.d.ts

@@ -27,7 +27,7 @@ export declare function listFilesChangedSinceSnapshot(projectPath: string, snaps
 /**
  * Lists dirty tracked files and untracked files in the working tree.
  */
-export declare function listWorkingTreeChangedFiles(projectPath: string): Promise<ReadonlyArray<string>>;
+export declare function listWorkingTreeChangedFiles(projectPath: string, env?: Record<string, string>): Promise<ReadonlyArray<string>>;
 /**
  * Reads the content hash of one repository-relative working tree file.
  *

package/umd/scripts/run-codex-prompts/isolation/coderIsolationArtifacts.d.ts

@@ -0,0 +1,16 @@
+import type { CoderCommitScope } from '../git/coderCommitScope';
+import type { PromptSelection } from '../prompts/types/PromptSelection';
+/** Original artifact content, checked before isolated writers run or publish into supported durable locations. */
+export type CoderIsolationArtifactBoundary = {
+    readonly repositoryRoot: string;
+    readonly objectFormat: string;
+    readonly paths: ReadonlyArray<string>;
+    readonly hashes: ReadonlyMap<string, string>;
+};
+/** Captures even ignored original logs and refuses pre-existing staged/unstaged artifacts before execution. */
+export declare function captureCoderIsolationArtifacts(scope: CoderCommitScope, selection: PromptSelection): Promise<CoderIsolationArtifactBoundary | undefined>;
+/**
+ * Eligible artifacts travel in the execution commits and integration. Ignored or failed-round artifacts are
+ * copied back into their existing durable locations before cleanup; unexpected original edits are retained.
+ */
+export declare function preserveCoderIsolationArtifacts(boundary: CoderIsolationArtifactBoundary | undefined, executionRoot: string): Promise<void>;

package/umd/scripts/run-codex-prompts/isolation/coderIsolationIgnoredFiles.d.ts

@@ -0,0 +1,18 @@
+import type { CoderCommitScope } from '../git/coderCommitScope';
+/** Ignored execution output is retained without making it eligible for an automatic commit. */
+export type CoderIsolationIgnoredBoundary = {
+    readonly repositoryRoot: string;
+    readonly objectFormat: string;
+    readonly original: ReadonlyMap<string, string>;
+    readonly executionBefore?: ReadonlyMap<string, string>;
+    readonly excludedPaths: ReadonlyArray<string>;
+};
+/** Captures the original ignored result before creating a worktree or running any owned writer. */
+export declare function captureCoderIsolationIgnoredFiles(scope: CoderCommitScope, excludedPaths: ReadonlyArray<string>): Promise<CoderIsolationIgnoredBoundary | undefined>;
+/** Establishes the actual execution baseline; original-only ignored files are never inferred as deletions. */
+export declare function beginCoderIsolationIgnoredFiles(boundary: CoderIsolationIgnoredBoundary | undefined, executionRoot: string): Promise<CoderIsolationIgnoredBoundary | undefined>;
+/**
+ * Retains only proven execution changes to ignored output before worktree removal. The existing isolation
+ * environment policy and known artifact retention stay separate, and concurrent original edits stop cleanup.
+ */
+export declare function preserveCoderIsolationIgnoredFiles(boundary: CoderIsolationIgnoredBoundary | undefined, executionRoot: string): Promise<void>;

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

@@ -17,8 +17,7 @@ type CreateCoderIsolationWorktreeOptions = {
 /**
  * Creates one temporary git worktree with its own branch and its own copy of the project environment.
  *
- * Leftovers of an earlier run of the same task are removed first so that a repeated task never fails
- * on an already existing worktree directory or branch.
+ * Existing recoverable branches/worktrees require explicit recovery and are never erased on a repeated task.
  */
 export declare function createCoderIsolationWorktree(options: CreateCoderIsolationWorktreeOptions): Promise<CoderIsolationWorktree>;
 export {};

package/umd/scripts/run-codex-prompts/isolation/mergeCoderIsolationWorktree.d.ts

@@ -1,4 +1,5 @@
 import type { CoderIsolationWorktree } from './CoderIsolationWorktree';
+import { type CoderRepositorySnapshot } from '../git/coderRepositorySnapshot';
 /**
  * Outcome of merging one isolated task back into the branch the coder runs on.
  */
@@ -14,11 +15,10 @@ export type CoderIsolationMergeResult = {
 /**
  * Merges the isolated task back into the branch the coder runs on.
  *
- * The merge is squashed so that the isolated task produces exactly one commit on the original branch,
- * exactly like a task processed without `--isolate`. The changes are only staged here; the caller
- * creates the commit so that the prompt status update becomes part of the very same commit.
+ * Fast-forward integration preserves implementation/check/finalization history exactly as verified in
+ * the execution checkout. Diverged or overlapping work is retained for manual integration.
  *
- * A failed merge never leaves the original working tree in a conflicted state and is reported back
+ * A refused fast-forward leaves the original working tree untouched and is reported back
  * instead of thrown, because a merge failure must not stop the coder from processing the next task.
  */
-export declare function mergeCoderIsolationWorktree(worktree: CoderIsolationWorktree): Promise<CoderIsolationMergeResult>;
+export declare function mergeCoderIsolationWorktree(worktree: CoderIsolationWorktree, original?: CoderRepositorySnapshot, signal?: AbortSignal): Promise<CoderIsolationMergeResult>;

package/umd/scripts/run-codex-prompts/isolation/preserveCoderIsolationRecovery.d.ts

@@ -0,0 +1,3 @@
+import type { CoderIsolationWorktree } from './CoderIsolationWorktree';
+/** Keeps durable phase/persistence records before Git removes an integrated worktree's private Git directory. */
+export declare function preserveCoderIsolationRecovery(worktree: CoderIsolationWorktree): Promise<void>;

package/umd/scripts/run-codex-prompts/isolation/runIsolatedPromptRound.d.ts

@@ -3,8 +3,8 @@ import type { RunPromptRoundOptions } from '../main/runPromptRound';
  * Runs one prompt round inside a temporary git worktree and merges the result back afterwards.
  *
  * This is the `--isolate` counterpart of `runPromptRound`, so it accepts exactly the same input:
- * - The coding agent, its verification command and the round commit all happen inside the worktree.
- * - A verified task is squash-merged back into the branch the coder runs on and the worktree is deleted.
+ * - The coding agent, its check command and the round commit all happen inside the worktree.
+ * - Verified phase commits are fast-forwarded back into the caller's branch and the worktree is deleted.
  * - A task which cannot be merged is recorded as failed in the original project and its worktree is kept,
  *   without stopping the coder from processing the next task.
  * - A task whose round fails keeps its worktree too, so the work of the failed round can still be inspected.

package/umd/scripts/run-codex-prompts/main/prepareCoderPromptExecution.d.ts

@@ -0,0 +1,18 @@
+import type { RunOptions } from '../cli/RunOptions';
+import { type PromptRunnerSelectionOptions } from './resolvePromptRunner';
+/** Resolves the same Book, harness, team bridge and attribution for queued and check-repair rounds. */
+export declare function prepareCoderPromptExecution(options: Pick<RunOptions, 'agent' | 'noCommit' | 'dryRun' | 'workspace'> & PromptRunnerSelectionOptions & {
+    readonly projectPath: string;
+}, preparation?: {
+    readonly isCommittingInitializedBooks?: boolean;
+    readonly signal?: AbortSignal;
+}): Promise<{
+    runner: import("../runners/types/PromptRunner").PromptRunner;
+    resolvedCoderAgent: import("../common/resolveCoderAgent").ResolvedCoderAgent | undefined;
+    runnerMetadata: {
+        agentName: string | undefined;
+        runnerName: string;
+        modelName?: string | undefined;
+    };
+    actualRunnerModel?: string | undefined;
+}>;

package/umd/scripts/run-codex-prompts/main/runCoderFix.d.ts

@@ -0,0 +1,24 @@
+import type { WorkspaceRepositoryContext } from '../../../src/cli/cli-commands/common/workspaceRepository';
+import type { NormalizedQuestionsCliOptions } from '../../../src/cli/cli-commands/common/questionsCliOptions';
+import type { NormalizedPromptRunnerCliOptions } from '../../../src/cli/cli-commands/common/promptRunnerCliOptions';
+import type { ResolvedCoderProjectContext } from '../common/resolveCoderProjectContext';
+import { type CoderCheckRepairResult } from '../checks/runCoderCheckRepair';
+/** Resolved finite check-repair inputs. Queue limits, filters and keep-alive state are intentionally absent. */
+export type CoderFixOptions = NormalizedPromptRunnerCliOptions & NormalizedQuestionsCliOptions & {
+    readonly workspace: WorkspaceRepositoryContext;
+    readonly projectContext: ResolvedCoderProjectContext;
+    readonly dryRun: boolean;
+    readonly checkCommand: string;
+    readonly agent?: string;
+    readonly context?: string;
+    readonly preserveLogs: boolean;
+    readonly waitAfterError: number;
+    readonly signal?: AbortSignal;
+};
+/** Validates fix's shared execution policy without exposing a queue-mode or interrupted-backlog escape hatch. */
+export declare function validateCoderFixOptions(options: Omit<CoderFixOptions, 'workspace' | 'projectContext'>): void;
+/**
+ * Checks and repairs one project, then returns an explicit outcome. No ordinary queue module is loaded or called.
+ * Both initial verification and repair use the very same service used by run's check-before phase.
+ */
+export declare function runCoderFix(providedOptions: CoderFixOptions): Promise<CoderCheckRepairResult>;

package/umd/scripts/run-codex-prompts/main/runPromptRound.d.ts

@@ -2,14 +2,17 @@ import type { RunOptions } from '../cli/RunOptions';
 import type { CliProgressDisplay } from '../common/cliProgressDisplay';
 import type { WaitForCoderRunPauseCheckpoint } from '../common/CoderRunPauseCheckpoint';
 import type { PromptRunnerMetadata } from '../common/PromptRunnerMetadata';
+import type { CoderCommitScope } from '../git/coderCommitScope';
 import type { PromptSelection } from '../prompts/types/PromptSelection';
 import type { PromptRunner } from '../runners/types/PromptRunner';
 import type { CoderRunUiHandle } from '../ui/renderCoderRunUi';
+/** Execution policy for one selected task; no queue, watcher or priority state is required. */
+export type PromptRoundExecutionOptions = Pick<RunOptions, 'workspace' | 'projectPath' | 'checkCommand' | 'preserveLogs' | 'thinkingLevel' | 'waitForUser' | 'waitAfterError' | 'noCommit' | 'normalizeLineEndings' | 'autoMigrate' | 'allowDestructiveAutoMigrate' | 'autoPush' | 'isIsolated' | 'agentName' | 'model' | 'agent' | 'context' | 'projectContext'>;
 /**
  * Input required to execute one prompt-processing round.
  */
 export type RunPromptRoundOptions = {
-    options: RunOptions;
+    options: PromptRoundExecutionOptions;
     runner: PromptRunner;
     runnerMetadata: PromptRunnerMetadata;
     nextPrompt: PromptSelection;
@@ -29,10 +32,17 @@ export type RunPromptRoundOptions = {
     projectPath?: string;
     /** Explicit durable artifact location when a temporary execution worktree will be deleted. */
     artifactsProjectPath?: string;
+    /** Scope captured before check-repair authoring and lazy Book initialization. */
+    commitScope?: CoderCommitScope;
+    /** Last retained no-commit phase of this same job, never an unrelated worker's dirty-file list. */
+    ownershipScope?: CoderCommitScope;
+    onScopeRetained?: (scope: CoderCommitScope) => void;
+    /** Cancels only this round's owned subprocesses and retry waits. */
+    signal?: AbortSignal;
 };
 /**
  * Runs one prompt round from prompt construction through commit or failure logging.
  *
  * @private function of runCodexPrompts
  */
-export declare function runPromptRound({ options, runner, runnerMetadata, nextPrompt, promptLabel, resolvedCoderContext, resolvedAgentSystemMessage, isRichUiEnabled, progressDisplay, uiHandle, waitForRequestedPause, projectPath, artifactsProjectPath, }: RunPromptRoundOptions): Promise<void>;
+export declare function runPromptRound(options: RunPromptRoundOptions): Promise<void>;

package/umd/scripts/run-codex-prompts/prompts/buildPromptRunTraceContent.d.ts

@@ -4,6 +4,7 @@ import type { CoderRunStep } from '../common/CoderRunStep';
 import { type FormatRunnerSignatureOptions } from './formatRunnerSignature';
 import type { PromptFile } from './types/PromptFile';
 import type { PromptSection } from './types/PromptSection';
+import type { CoderPhaseCommitResult } from '../git/CoderPhasePersistence';
 /**
  * How one prompt round the trace describes has ended.
  *
@@ -35,7 +36,7 @@ export type BuildPromptRunTraceContentOptions = FormatRunnerSignatureOptions & {
     readonly file: PromptFile;
     readonly section: PromptSection;
     /**
-     * Verification command the round ran after each coding attempt, when one is configured.
+     * Aggregate check command the round ran after each coding attempt, when one is configured.
      */
     readonly checkCommand?: string;
     /**
@@ -53,9 +54,11 @@ export type BuildPromptRunTraceContentOptions = FormatRunnerSignatureOptions & {
     readonly outcome: PromptRunTraceOutcome;
     /**
      * Raw runtime log of the round, holding the generated shell scripts and everything the harness and the
-     * verification command have written. Empty when the round produced no readable runtime log.
+     * check command have written. Empty when the round produced no readable runtime log.
      */
     readonly runtimeLog: string;
+    /** Chronological local phase persistence; no-commit phases retain an absent commit identity. */
+    readonly phaseCommits?: ReadonlyArray<CoderPhaseCommitResult>;
 };
 /**
  * Renders the markdown run trace of one finished or failed prompt round.

package/umd/scripts/run-codex-prompts/prompts/refreshPromptSelection.d.ts

@@ -0,0 +1,6 @@
+import type { PromptSelection } from './types/PromptSelection';
+/**
+ * Refreshes on-disk task content before a Coder status write. The caller owns a validated mutation boundary;
+ * agent/check edits to the task body must survive status persistence just like edits to any other file.
+ */
+export declare function refreshPromptSelection(selection: PromptSelection): Promise<void>;

package/umd/scripts/run-codex-prompts/prompts/writePromptErrorLog.d.ts

@@ -16,4 +16,8 @@ type WritePromptErrorLogOptions = {
  * Returns the path of the written log so callers can include it in a commit.
  */
 export declare function writePromptErrorLog(options: WritePromptErrorLogOptions): Promise<string>;
+/**
+ * Returns the failure log path for a prompt markdown file.
+ */
+export declare function buildPromptErrorLogPath(promptPath: string): string;
 export {};

package/umd/scripts/run-codex-prompts/prompts/writePromptFile.d.ts

@@ -3,3 +3,5 @@ import type { PromptFile } from './types/PromptFile';
  * Writes updated prompt file content to disk.
  */
 export declare function writePromptFile(file: PromptFile): Promise<void>;
+/** Serializes a status candidate identically for private-tree persistence and ordinary prompt writes. */
+export declare function buildPromptFileContent(file: PromptFile): string;

package/umd/scripts/run-codex-prompts/prompts/writePromptRunTrace.d.ts

@@ -10,6 +10,8 @@ export type WritePromptRunTraceOptions = Omit<BuildPromptRunTraceContentOptions,
      * Path of the temporary live runtime log of the round, when the round has one.
      */
     readonly logPath?: string;
+    /** Defers publication until the completion tree is persisted by the shared Git service. */
+    readonly writeContent?: (path: string, content: string) => Promise<void>;
 };
 /**
  * Writes the run trace of one prompt round into the `traces` directory of the prompts directory.

package/umd/scripts/run-codex-prompts/server/buildCoderServerPromptResponse.d.ts

@@ -10,7 +10,7 @@ export type CoderServerBoardColumn = 'backlog' | 'low-priority' | 'todo' | 'in-p
  * UI tag attached to one prompt card.
  */
 export type CoderServerPromptTag = {
-    readonly id: 'not-ready' | 'unwritten' | 'left-in-progress' | 'implementing' | 'verifying';
+    readonly id: 'not-ready' | 'unwritten' | 'left-in-progress' | 'implementing' | 'checking';
     readonly label: string;
 };
 /**

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

@@ -16,7 +16,7 @@ import { CoderRunOutput } from './output/CoderRunOutput';
  *
  * @private internal type of coder run UI
  */
-export type CoderRunPhase = 'initializing' | 'loading' | 'running' | 'verifying' | 'waiting' | 'paused' | 'done' | 'error';
+export type CoderRunPhase = 'initializing' | 'loading' | 'running' | 'checking' | 'waiting' | 'paused' | 'done' | 'error';
 /**
  * Configuration display data for the coder run UI header.
  *

package/umd/scripts/run-codex-prompts/ui/buildCoderCheckRepairUiFrame.d.ts

@@ -0,0 +1,3 @@
+import type { BuildCoderRunUiFrameOptions } from './buildCoderRunUiFrame';
+/** Renders a finite check/repair job without queue statistics, priority scope, or next-task controls. */
+export declare function buildCoderCheckRepairUiFrame(options: BuildCoderRunUiFrameOptions): string[];

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

@@ -1,7 +1,7 @@
 /** 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';
+export type CoderOutputKind = 'agent' | 'reasoning' | 'tool' | 'files' | 'check' | 'result' | 'warning' | 'error' | 'status' | 'unknown';
 /** A bounded presentation entry, separate from the original harness chunks and durable trace. */
 export type CoderOutputEvent = {
     readonly id?: string;

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

@@ -22,11 +22,11 @@ export declare class CoderRunOutput {
     /** 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;
+    append(chunk: string, source: LiveScriptOutputSource, harnessName: string, isCheck: 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;
+    appendRunner(text: string, kind?: 'status' | 'warning' | 'error' | 'check'): 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. */

package/umd/scripts/run-codex-prompts/ui/renderCoderRunUi.d.ts

@@ -34,4 +34,8 @@ export type CoderRunUiHandle = {
 export declare function renderCoderRunUi(startTime: moment.Moment, options?: {
     readonly buildFrameLines?: (options: BuildCoderRunUiFrameOptions) => string[];
     readonly state?: CoderRunUiState;
+    /** Finite jobs cancel their owned activity and finish cleanup instead of exiting directly from a keypress. */
+    readonly onInterrupt?: () => void;
+    /** Jobs without a queue need presentation controls only, independent of global run pause state. */
+    readonly isQueueControlsEnabled?: boolean;
 }): CoderRunUiHandle;

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

@@ -1,5 +1,6 @@
 import type { Command as Program } from 'commander';
 import type { $side_effect } from '../../../utils/organization/$side_effect';
+import { type ResolvedCoderPromptTemplate } from './boilerplateTemplates';
 /**
  * Initializes `coder add` command for Promptbook CLI utilities
  *
@@ -28,11 +29,13 @@ export type AddCoderPromptResult = {
  *
  * @private internal utility of `coder add` command
  */
-export declare function addCoderPrompt({ projectPath, description, priority, templateOption, }: {
+export declare function addCoderPrompt({ projectPath, description, priority, templateOption, promptTemplate, }: {
     readonly projectPath: string;
     readonly description: string;
     readonly priority: number;
     readonly templateOption?: string;
+    /** Internal authoring workflows may supply their own bounded instructions instead of the feature template. */
+    readonly promptTemplate?: ResolvedCoderPromptTemplate;
 }): Promise<AddCoderPromptResult>;
 /**
  * Prepares a numbered, emoji-tagged prompt for preview without writing the prompt file.
@@ -40,13 +43,15 @@ export declare function addCoderPrompt({ projectPath, description, priority, tem
  *
  * @private internal utility shared by `coder add` and `coder plan`
  */
-export declare function prepareCoderPrompt({ projectPath, description, priority, templateOption, numberOffset, reservedEmojiTag, }: {
+export declare function prepareCoderPrompt({ projectPath, description, priority, templateOption, numberOffset, reservedEmojiTag, promptTemplate: providedPromptTemplate, }: {
     readonly projectPath: string;
     readonly description: string;
     readonly priority: number;
     readonly templateOption?: string;
     readonly numberOffset?: number;
     readonly reservedEmojiTag?: string;
+    /** Shared repair authoring preserves numbering and tags without appending ordinary implementation instructions. */
+    readonly promptTemplate?: ResolvedCoderPromptTemplate;
 }): Promise<AddCoderPromptResult & {
     readonly content: string;
 }>;

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,7 @@
 import { type PromptRunnerHarnessName } from '../common/promptRunnerCliOptions';
 import type { InitializationStatus } from './boilerplateTemplates';
 /**
- * Ensures `.gitignore` contains Promptbook Coder's local artifacts and every supported harness's local artifacts.
+ * Ensures `.gitignore` covers local dependencies, coder artifacts and every supported harness's local artifacts.
  *
  * @private function of `initializeCoderProjectConfiguration`
  */

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/initializeCoderProjectConfiguration.d.ts

@@ -15,6 +15,7 @@ export type CoderInitializationSummary = {
     readonly adamAgentFileDiagnostic?: string;
     readonly envFileStatus: InitializationStatus;
     readonly gitignoreFileStatus: InitializationStatus;
+    readonly gitattributesFileStatus: InitializationStatus;
     readonly packageJsonFileStatus: InitializationStatus;
     readonly vscodeSettingsFileStatus: InitializationStatus;
     readonly addedPackageJsonScriptNames: ReadonlyArray<string>;

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

@@ -11,6 +11,7 @@ import type { $side_effect } from '../../utils/organization/$side_effect';
  * - find-refactor-candidates: Find files that need refactoring
  * - list: List ready prompts in priority order without running them
  * - run: Run coding prompts with AI agents
+ * - fix: Check and repair the project, then exit without processing the queue
  * - ping: Test one harness and model with a tiny dummy prompt
  * - verify: Verify completed prompts
  * - find-fresh-emoji-tags: Find unused emoji tags

package/umd/src/cli/cli-commands/common/coderCheckCliOptions.d.ts

@@ -8,7 +8,7 @@ export declare const LEGACY_CODER_CHECK_OPTIONS: readonly [readonly ["--test", "
  * Registers the shared project check command and rejects retired aggregate-test spellings.
  * @private shared CLI registration for Coder execution
  */
-export declare function addCoderCheckOptions(command: Command, isCheckBeforeSupported: boolean): void;
+export declare function addCoderCheckOptions(command: Command, isCheckBeforeSupported: boolean, description?: string): void;
 /**
  * Builds the same actionable migration diagnostic for registered and direct-script entrypoints.
  * @private shared CLI diagnostic for Coder execution

package/umd/src/cli/cli-commands/common/ensureProjectTextFile.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectInitializationStatus } from './projectInitialization';
+/**
+ * Creates one project text file with default content, preserving any existing file.
+ *
+ * @private internal utility of Promptbook CLI project initialization
+ */
+export declare function ensureProjectTextFile(projectPath: string, relativeFilePath: string, fileContent: string): Promise<ProjectInitializationStatus>;

package/umd/src/cli/cli-commands/common/harness/$ensureHarnessInstallations.d.ts

@@ -11,4 +11,6 @@ import type { NormalizedQuestionsCliOptions } from '../questionsCliOptions';
  *
  * @private internal utility of `promptbookCli`
  */
-export declare function $ensureHarnessInstallations(harnessNames: ReadonlyArray<PromptRunnerHarnessName | undefined>, questionsOptions: NormalizedQuestionsCliOptions): Promise<void>;
+export declare function $ensureHarnessInstallations(harnessNames: ReadonlyArray<PromptRunnerHarnessName | undefined>, questionsOptions: NormalizedQuestionsCliOptions, options?: {
+    readonly isRequired?: boolean;
+}): Promise<void>;

package/umd/src/cli/cli-commands/common/validateCoderRunOptions.d.ts

@@ -3,4 +3,4 @@ import type { RunOptions } from '../../../../scripts/run-codex-prompts/cli/RunOp
  * Validates cross-flag constraints before workspace setup or the run starts.
  * @private shared validation for Coder execution commands
  */
-export declare function validateCoderRunOptions(options: RunOptions): void;
+export declare function validateCoderRunOptions(options: Pick<RunOptions, 'checkCommand' | 'checkBefore' | 'allowDestructiveAutoMigrate' | 'autoMigrate' | 'noCommit' | 'waitForUser' | 'gitChanges' | 'autoPull' | 'dryRun' | 'isIsolated' | 'limit'>): void;

package/umd/src/cli/cli-commands/common/workspaceRepository.d.ts

@@ -1,3 +1,5 @@
+/// <reference types="node" />
+/// <reference types="node" />
 import type { NormalizedQuestionsCliOptions } from './questionsCliOptions';
 /**
  * Resolved project directory and its enclosing working tree. Project artifacts belong to `projectPath`;
@@ -34,3 +36,13 @@ export declare function $preflightWorkspaceRepository(options: {
     readonly projectDirectory?: string;
     readonly policy: WorkspaceRepositoryPolicy;
 } & Partial<NormalizedQuestionsCliOptions>): Promise<WorkspaceRepositoryContext>;
+/**
+ * Executes Git without a shell, optional index locks, or credential prompts, retaining raw output boundaries.
+ * Drains both output streams without execFile's fixed buffer limit so large repository listings remain complete.
+ * @private shared Git discovery and commit-scope inspection
+ */
+export declare function $runWorkspaceGit(projectPath: string, argumentsList: ReadonlyArray<string>, options?: {
+    readonly env?: Record<string, string>;
+    readonly signal?: AbortSignal;
+    readonly input?: string | Buffer;
+}): Promise<string>;

package/umd/src/version.d.ts

@@ -15,7 +15,7 @@ export declare const BOOK_LANGUAGE_VERSION: string_semantic_version;
 export declare const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version;
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.114.0-48`).
+ * It follows semantic versioning (e.g., `0.114.0-49`).
  *
  * @generated
  */