@promptbook/node 0.114.0-19 → 0.114.0-20

package/README.md

@@ -482,7 +482,7 @@ In short: tools like Claude Code, Codex, or GitHub Copilot are the **engines**;
 5. Promptbook Coder marks the prompt as done `[x]`, records runner metadata, then stages, commits, and pushes the resulting changes.
 6. `ptbk coder verify` reviews completed prompts, archives finished files to `prompts/done/`, and appends a repair prompt when more work is needed.
 
-Prompts marked with `[-]` are not ready yet, prompts containing `@@@` are treated as not fully written, and prompts with more `!` markers have higher priority. A prompt left as `[^]` was interrupted in the middle of its implementation — the in-progress status is never reverted, so a killed or crashed coder always leaves that signal behind.
+Prompts marked with `[-]` are not ready yet, prompts containing `@@@` are treated as not fully written, and prompts with more `!` markers have higher priority. A prompt left as `[^]` was interrupted in the middle of its implementation — the in-progress status is never reverted, so a killed or crashed coder always leaves that signal behind, and `--git-changes continue` resumes exactly that prompt with its uncommitted changes still in place.
 
 #### Features
 
@@ -490,7 +490,7 @@ Prompts marked with `[-]` are not ready yet, prompts containing `@@@` are treate
 -   **Context injection:** `--agent agents/coding/developer.book --context AGENTS.md` or inline extra instructions
 -   **Reasoning control:** `--thinking-level low|medium|high|xhigh` for supported runners
 -   **Unattended or interactive runs:** default auto mode, or `--no-auto` to wait for user confirmation before each prompt
--   **Git safety:** clean working tree check by default, optional `--ignore-git-changes`
+-   **Git safety:** clean working tree check by default, or `--git-changes ignore` to keep the changes and `--git-changes continue` to resume an interrupted prompt
 -   **Opt-in remote pushes:** commits stay local unless you explicitly pass `--auto-push`
 -   **Prompt triage:** `--priority` to process only more important tasks first
 -   **Failure logging:** failed runs write a neighboring `.error.log`
@@ -511,7 +511,7 @@ npx ts-node ./src/cli/test/ptbk.ts coder run --harness github-copilot --model gp
 
 npx ts-node ./src/cli/test/ptbk.ts coder run --harness github-copilot --model gpt-5.4 --thinking-level xhigh --agent agents/coding/developer.book --context AGENTS.md --auto-push
 
-npx ts-node ./src/cli/test/ptbk.ts coder run --harness github-copilot --model gpt-5.4 --thinking-level xhigh --agent agents/coding/developer.book --context AGENTS.md --ignore-git-changes
+npx ts-node ./src/cli/test/ptbk.ts coder run --harness github-copilot --model gpt-5.4 --thinking-level xhigh --agent agents/coding/developer.book --context AGENTS.md --git-changes ignore
 
 npx ts-node ./src/cli/test/ptbk.ts coder find-refactor-candidates
 
@@ -537,7 +537,7 @@ ptbk coder run --harness github-copilot --model gpt-5.4 --thinking-level xhigh -
 
 ptbk coder run --harness github-copilot --model gpt-5.4 --thinking-level xhigh --agent agents/coding/developer.book --context AGENTS.md --auto-push
 
-ptbk coder run --harness github-copilot --model gpt-5.4 --thinking-level xhigh --agent agents/coding/developer.book --context AGENTS.md --test npm run test --ignore-git-changes
+ptbk coder run --harness github-copilot --model gpt-5.4 --thinking-level xhigh --agent agents/coding/developer.book --context AGENTS.md --test npm run test --git-changes ignore
 
 ptbk coder find-refactor-candidates
 
@@ -569,7 +569,7 @@ ptbk coder verify
 | `--test-before <mode>`     | Runs tests before coding: `no` (default), `yes-and-fail` (stop with results), or `yes-and-fix` (create one repair prompt first); defaults to `npm test` when enabled without `--test`. |
 | `--thinking-level <level>` | Sets reasoning effort for supported runners.                                                                                                                                           |
 | `--no-auto`                | Waits for user confirmation before each prompt instead of running automatically through the queue.                                                                                     |
-| `--ignore-git-changes`     | Disables the clean-working-tree guard.                                                                                                                                                 |
+| `--git-changes <mode>`     | Decides what happens with a dirty working tree: `fail` (default), `ignore` to keep the changes, or `continue` to resume the single interrupted `[^]` prompt with them.                 |
 | `--priority <n>`           | Runs only prompts at or above the given priority.                                                                                                                                      |
 | `--dry-run`                | Prints which prompts are ready instead of executing them.                                                                                                                              |
 | `--allow-credits`          | Lets OpenAI Codex spend credits when required.                                                                                                                                         |

package/esm/index.es.js

@@ -29,7 +29,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @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
@@ -3241,6 +3241,97 @@ async function $runGoScriptWithOutput(options) {
     });
 }
 
+/**
+ * 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.
  */
@@ -3290,6 +3381,32 @@ async function waitForRegularMilliseconds(durationMs) {
     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.
  */
@@ -3697,6 +3814,10 @@ class ClaudeCodeRunner {
 }
 /**
  * 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;
@@ -3707,7 +3828,7 @@ async function waitForClaudeCodeSessionLimitReset(sessionLimit, resurrectionCoun
     if ((_a = options.shouldPrintLiveOutput) !== null && _a !== void 0 ? _a : true) {
         console.warn(colors.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) => {
@@ -29543,7 +29664,7 @@ function createPromptRunnerOptions(options) {
         waitBetweenPrompts: 0,
         waitAfterError: 0,
         noCommit: true,
-        ignoreGitChanges: true,
+        gitChanges: 'ignore',
         normalizeLineEndings: false,
         allowCredits: options.allowCredits,
         isVerbose: options.isVerbose,