@promptbook/node 0.114.0-19 → 0.114.0-20

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

@@ -0,0 +1,92 @@
+/**
+ * Pause lifecycle of `ptbk coder run`.
+ */
+export type CoderRunPauseState = 'RUNNING' | 'PAUSING' | 'PAUSED';
+/**
+ * Result of toggling the pause hotkey state.
+ */
+export type CoderRunPauseToggleResult = 'REQUESTED_PAUSE' | 'CANCELLED_PAUSE' | 'RESUMED';
+/**
+ * Result of requesting a timed wait skip.
+ */
+export type CoderRunSkipCurrentWaitResult = 'REQUESTED_SKIP' | 'NO_ACTIVE_WAIT';
+/**
+ * Result of toggling the dynamic end-after-current-prompt state.
+ */
+export type CoderRunEndAfterCurrentPromptToggleResult = 'REQUESTED_END' | 'CANCELLED_END';
+/**
+ * Token that identifies one active timed wait which can be skipped by the user.
+ */
+export type CoderRunSkippableWaitToken = symbol;
+/**
+ * Applies the same three-state toggle used by the `P` hotkey.
+ */
+export declare function togglePauseState(): CoderRunPauseToggleResult;
+/**
+ * Applies the two-state toggle used by the `X` hotkey.
+ */
+export declare function toggleEndAfterCurrentPromptState(): CoderRunEndAfterCurrentPromptToggleResult;
+/**
+ * Returns whether the dynamic end-after-current-prompt control is active.
+ */
+export declare function getEndAfterCurrentPromptState(): boolean;
+/**
+ * Starts one timed wait which can be skipped by the `S` hotkey.
+ */
+export declare function beginSkippableWait(): CoderRunSkippableWaitToken;
+/**
+ * Finishes one timed wait and clears any skip request that belonged to it.
+ */
+export declare function finishSkippableWait(waitToken: CoderRunSkippableWaitToken): void;
+/**
+ * Requests that the currently active timed wait ends immediately.
+ */
+export declare function requestSkipCurrentWait(): CoderRunSkipCurrentWaitResult;
+/**
+ * Returns whether one timed wait should end early.
+ */
+export declare function shouldSkipCurrentWait(waitToken: CoderRunSkippableWaitToken): boolean;
+/**
+ * Waits for either a timeout or an `S` hotkey skip request.
+ */
+export declare function waitForSkippableMilliseconds(waitToken: CoderRunSkippableWaitToken, durationMs: number): Promise<void>;
+/**
+ * Restores all shared terminal controls to their default state.
+ */
+export declare function resetCoderRunControls(): void;
+/**
+ * If the execution is paused, it will wait until it is resumed.
+ *
+ * @param options.silent - When `true`, suppresses console output (used when the terminal UI handles display).
+ * @param options.onPaused - Callback invoked when entering the PAUSED state.
+ * @param options.onResumed - Callback invoked when leaving the PAUSED state.
+ */
+export declare function checkPause(options?: {
+    silent?: boolean;
+    onPaused?: () => void;
+    onResumed?: () => void;
+}): Promise<void>;
+/**
+ * Returns the current pause state for external consumers such as the terminal UI.
+ */
+export declare function getPauseState(): CoderRunPauseState;
+/**
+ * Returns the label of the next checkpoint where pausing will take effect.
+ */
+export declare function getPauseTargetLabel(): string;
+/**
+ * Updates the label of the next pause checkpoint.
+ */
+export declare function announcePauseTargetLabel(nextPauseTargetLabel: string): void;
+/**
+ * Restores the default generic pause target label.
+ */
+export declare function resetPauseTargetLabel(): void;
+/**
+ * Requests a pause from an external controller (e.g. the Ink UI).
+ */
+export declare function requestPause(): void;
+/**
+ * Resumes execution from an external controller after a pause.
+ */
+export declare function requestResume(): void;

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

@@ -0,0 +1,15 @@
+import { type WorldTimeDeadlineTick } from './waitUntilWorldTimeDeadline';
+/**
+ * Waits until one wall-clock deadline has passed, or until the user skips the wait with the `S` control.
+ *
+ * This is the single way `ptbk coder` waits for a deadline the user is allowed to cut short, so every
+ * wait which shows the `S  Skip current waiting` control really reacts to it: the pacing waits between
+ * prompts, the cool-down after an error, the harness session-limit waits and the server keep-alive poll.
+ *
+ * @private internal utility of `ptbk coder` wait handling
+ */
+export declare function waitForSkippableWorldTimeDeadline(options: {
+    readonly deadlineTimeMs: number;
+    readonly pollIntervalMs: number;
+    readonly onTick?: WorldTimeDeadlineTick;
+}): Promise<void>;

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

@@ -0,0 +1,28 @@
+/**
+ * Supported values of the `--git-changes` option, which decides what happens with a dirty working tree.
+ *
+ * - `fail` — refuse to start while the working tree has uncommitted changes
+ * - `ignore` — start anyway and leave the uncommitted changes where they are
+ * - `continue` — resume the single prompt which was left in the middle of its implementation
+ *
+ * @private internal shared utility of `ptbk coder run`
+ */
+export declare const GIT_CHANGES_MODE_VALUES: readonly ["fail", "ignore", "continue"];
+/**
+ * Behavior requested for a working tree which has uncommitted changes.
+ *
+ * @private internal shared utility of `ptbk coder run`
+ */
+export type GitChangesMode = (typeof GIT_CHANGES_MODE_VALUES)[number];
+/**
+ * Mode applied when `--git-changes` is not used at all.
+ *
+ * @private internal shared utility of `ptbk coder run`
+ */
+export declare const DEFAULT_GIT_CHANGES_MODE: GitChangesMode;
+/**
+ * Checks whether a value is a supported `--git-changes` mode.
+ *
+ * @private internal shared utility of `ptbk coder run`
+ */
+export declare function isGitChangesMode(value: string): value is GitChangesMode;

package/esm/src/cli/cli-commands/common/promptRunnerCliOptions.d.ts

@@ -1,5 +1,6 @@
 import { Command as Program } from 'commander';
 import { PTBK_HARNESS_ENV, PTBK_MODEL_ENV, PTBK_THINKING_LEVEL_ENV } from '../../../book-3.0/cliAgentEnv';
+import type { GitChangesMode } from '../coder/GitChangesMode';
 import type { ThinkingLevel } from '../coder/ThinkingLevel';
 export { PTBK_HARNESS_ENV, PTBK_MODEL_ENV, PTBK_THINKING_LEVEL_ENV };
 /**
@@ -25,7 +26,7 @@ export type PromptRunnerCliOptions = {
     readonly ui: boolean;
     readonly thinkingLevel?: ThinkingLevel;
     readonly commit: boolean;
-    readonly ignoreGitChanges: boolean;
+    readonly gitChanges: GitChangesMode;
     readonly allowCredits: boolean;
     readonly normalizeLineEndings: boolean;
     readonly autoPush: boolean;
@@ -48,7 +49,7 @@ export type NormalizedPromptRunnerCliOptions = {
     readonly noUi: boolean;
     readonly thinkingLevel?: ThinkingLevel;
     readonly noCommit: boolean;
-    readonly ignoreGitChanges: boolean;
+    readonly gitChanges: GitChangesMode;
     readonly allowCredits: boolean;
     readonly normalizeLineEndings: boolean;
     readonly autoPush: boolean;
@@ -78,6 +79,12 @@ export declare const PROMPT_RUNNER_HARNESS_OPTION_DESCRIPTION = "Select runner:
  * @private internal utility of `promptbookCli`
  */
 export declare const PROMPT_RUNNER_MODEL_OPTION_DESCRIPTION: string;
+/**
+ * Commander description for the `--git-changes` option.
+ *
+ * @private internal utility of `promptbookCli`
+ */
+export declare const GIT_CHANGES_OPTION_DESCRIPTION: string;
 /**
  * Registers runner selection flags on a command.
  *

package/esm/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-18`).
+ * It follows semantic versioning (e.g., `0.114.0-19`).
  *
  * @generated
  */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/node",
-    "version": "0.114.0-19",
+    "version": "0.114.0-20",
     "description": "Promptbook: Create persistent AI agents that turn your company's scattered knowledge into action",
     "private": false,
     "sideEffects": false,
@@ -97,7 +97,7 @@
     "types": "./esm/src/_packages/node.index.d.ts",
     "typings": "./esm/src/_packages/node.index.d.ts",
     "peerDependencies": {
-        "@promptbook/core": "0.114.0-19"
+        "@promptbook/core": "0.114.0-20"
     },
     "dependencies": {
         "@openai/agents": "0.4.15",

package/umd/index.umd.js

@@ -47,7 +47,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.114.0-19';
+    const PROMPTBOOK_ENGINE_VERSION = '0.114.0-20';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -3259,6 +3259,97 @@
         });
     }
 
+    /**
+     * Token of the currently active timed wait, if the runner is inside one.
+     */
+    let activeSkippableWaitToken;
+    /**
+     * Whether the user requested the active timed wait to end immediately.
+     */
+    let isSkipCurrentWaitRequested = false;
+    /**
+     * Promise resolvers waiting for the active timed wait to be skipped.
+     */
+    const SKIP_CURRENT_WAIT_RESOLVERS = new Map();
+    /**
+     * Starts one timed wait which can be skipped by the `S` hotkey.
+     */
+    function beginSkippableWait() {
+        const waitToken = Symbol('coder-run-skippable-wait');
+        activeSkippableWaitToken = waitToken;
+        isSkipCurrentWaitRequested = false;
+        SKIP_CURRENT_WAIT_RESOLVERS.clear();
+        return waitToken;
+    }
+    /**
+     * Finishes one timed wait and clears any skip request that belonged to it.
+     */
+    function finishSkippableWait(waitToken) {
+        if (activeSkippableWaitToken !== waitToken) {
+            return;
+        }
+        activeSkippableWaitToken = undefined;
+        isSkipCurrentWaitRequested = false;
+        resolveSkipCurrentWaitResolvers(waitToken);
+        SKIP_CURRENT_WAIT_RESOLVERS.delete(waitToken);
+    }
+    /**
+     * Returns whether one timed wait should end early.
+     */
+    function shouldSkipCurrentWait(waitToken) {
+        return activeSkippableWaitToken === waitToken && isSkipCurrentWaitRequested;
+    }
+    /**
+     * Waits for either a timeout or an `S` hotkey skip request.
+     */
+    async function waitForSkippableMilliseconds(waitToken, durationMs) {
+        if (durationMs <= 0 || shouldSkipCurrentWait(waitToken)) {
+            return;
+        }
+        await new Promise((resolve) => {
+            let timeout = setTimeout(resolveWait, durationMs);
+            const resolver = () => resolveWait();
+            const resolvers = getSkipCurrentWaitResolvers(waitToken);
+            resolvers.add(resolver);
+            function resolveWait() {
+                if (timeout !== undefined) {
+                    clearTimeout(timeout);
+                    timeout = undefined;
+                }
+                resolvers.delete(resolver);
+                if (resolvers.size === 0) {
+                    SKIP_CURRENT_WAIT_RESOLVERS.delete(waitToken);
+                }
+                resolve();
+            }
+        });
+    }
+    /**
+     * Gets or creates the resolver set for one timed wait.
+     */
+    function getSkipCurrentWaitResolvers(waitToken) {
+        const existingResolvers = SKIP_CURRENT_WAIT_RESOLVERS.get(waitToken);
+        if (existingResolvers !== undefined) {
+            return existingResolvers;
+        }
+        const resolvers = new Set();
+        SKIP_CURRENT_WAIT_RESOLVERS.set(waitToken, resolvers);
+        return resolvers;
+    }
+    /**
+     * Resolves all pending skip waiters for one timed wait.
+     */
+    function resolveSkipCurrentWaitResolvers(waitToken) {
+        const resolvers = SKIP_CURRENT_WAIT_RESOLVERS.get(waitToken);
+        if (resolvers === undefined) {
+            return;
+        }
+        for (const resolver of resolvers) {
+            resolver();
+        }
+        resolvers.clear();
+    }
+
     /**
      * Minimum timer duration used to avoid a zero-millisecond polling loop.
      */
@@ -3308,6 +3399,32 @@
         await new Promise((resolve) => setTimeout(resolve, durationMs));
     }
 
+    /**
+     * Waits until one wall-clock deadline has passed, or until the user skips the wait with the `S` control.
+     *
+     * This is the single way `ptbk coder` waits for a deadline the user is allowed to cut short, so every
+     * wait which shows the `S  Skip current waiting` control really reacts to it: the pacing waits between
+     * prompts, the cool-down after an error, the harness session-limit waits and the server keep-alive poll.
+     *
+     * @private internal utility of `ptbk coder` wait handling
+     */
+    async function waitForSkippableWorldTimeDeadline(options) {
+        const { deadlineTimeMs, pollIntervalMs, onTick } = options;
+        const waitToken = beginSkippableWait();
+        try {
+            await waitUntilWorldTimeDeadline({
+                deadlineTimeMs,
+                pollIntervalMs,
+                onTick,
+                shouldStopWaiting: () => shouldSkipCurrentWait(waitToken),
+                waitForMilliseconds: (waitDurationMs) => waitForSkippableMilliseconds(waitToken, waitDurationMs),
+            });
+        }
+        finally {
+            finishSkippableWait(waitToken);
+        }
+    }
+
     /**
      * Base delimiter used for passing large prompts through stdin.
      */
@@ -3715,6 +3832,10 @@
     }
     /**
      * Waits until the Claude Code session can be resumed, keeping terminal status clear.
+     *
+     * The wait runs in the `waiting` phase, where the terminal UI offers `S  Skip current waiting`, so it is
+     * a skippable wait: pressing `S` resumes the session with `--resume` immediately instead of sitting out
+     * the reset window.
      */
     async function waitForClaudeCodeSessionLimitReset(sessionLimit, resurrectionCount, options) {
         var _a, _b;
@@ -3725,7 +3846,7 @@
         if ((_a = options.shouldPrintLiveOutput) !== null && _a !== void 0 ? _a : true) {
             console.warn(colors__default["default"].yellow(`[claude-code] Session limit detected for ${sessionLimit.sessionId}. Resurrection #${resurrectionCount} will resume with --resume after ${formatDurationMs(delayMs)}. ${resetSummary}`));
         }
-        await waitUntilWorldTimeDeadline({
+        await waitForSkippableWorldTimeDeadline({
             deadlineTimeMs: resetDeadlineTimeMs,
             pollIntervalMs: CLAUDE_CODE_SESSION_RESURRECTION_POLL_MS,
             onTick: async (remainingDelayMs) => {
@@ -29561,7 +29682,7 @@
             waitBetweenPrompts: 0,
             waitAfterError: 0,
             noCommit: true,
-            ignoreGitChanges: true,
+            gitChanges: 'ignore',
             normalizeLineEndings: false,
             allowCredits: options.allowCredits,
             isVerbose: options.isVerbose,