@promptbook/cli 0.112.0-45 → 0.112.0-47

package/umd/index.umd.js

@@ -60,7 +60,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-45';
+    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-47';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -1047,7 +1047,7 @@
      *
      * @public exported from `@promptbook/core`
      */
-    const CLAIM = `Turn your company's scattered knowledge into AI ready books`;
+    const CLAIM = `Create persistent AI agents that turn your company's scattered knowledge into action`;
     //            <- TODO: [🐊] Pick the best claim
     /**
      * Color of the Promptbook
@@ -1100,7 +1100,7 @@
      *
      * @public exported from `@promptbook/core`
      */
-    const DEFAULT_BOOK_TITLE = `✨ Untitled Book`;
+    const DEFAULT_BOOK_TITLE = `🐙 Untitled agent`;
     /**
      * When the title of task is not provided, the default title is used
      *
@@ -2490,37 +2490,68 @@
     }
     // Note: [🟡] Code for coder init environment bootstrapping [ensureCoderEnvFile](src/cli/cli-commands/coder/ensureCoderEnvFile.ts) should never be published outside of `@promptbook/cli`
 
+    /**
+     * @@@
+     *
+     * @public exported from `@promptbook/utils`
+     */
+    function escapeRegExp$1(value) {
+        return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+
     /**
      * Relative path to `.gitignore` in the initialized project.
      */
     const GITIGNORE_FILE_PATH = '.gitignore';
     /**
-     * `.gitignore` block required by standalone Promptbook coder projects.
+     * Promptbook coder temp directory that should stay out of version control.
      */
-    const CODER_GITIGNORE_BLOCK = _spaceTrim.spaceTrim(`
-    # Promptbook Coder
-    /.tmp
-`);
+    const CODER_TEMP_GITIGNORE_RULE = '/.tmp';
     /**
-     * Ensures `.gitignore` contains the standalone Promptbook coder cache entry.
+     * Promptbook coder cache directory that should stay out of version control.
+     */
+    const CODER_CACHE_GITIGNORE_RULE = '/.promptbook/ptbk-coder';
+    /**
+     * Standard header used when appending Promptbook coder rules into `.gitignore`.
+     */
+    const CODER_GITIGNORE_HEADER = '# Promptbook Coder';
+    /**
+     * Ensures `.gitignore` contains the standalone Promptbook coder temp and cache entries.
      *
      * @private function of `initializeCoderProjectConfiguration`
      */
     async function ensureCoderGitignoreFile(projectPath) {
         const gitignorePath = path.join(projectPath, GITIGNORE_FILE_PATH);
         const currentGitignoreContent = await readTextFileIfExists(gitignorePath);
-        if (currentGitignoreContent !== undefined && hasTmpGitignoreRule(currentGitignoreContent)) {
+        const missingRules = getMissingCoderGitignoreRules(currentGitignoreContent || '');
+        if (currentGitignoreContent !== undefined && missingRules.length === 0) {
             return 'unchanged';
         }
-        const nextGitignoreContent = appendBlock(currentGitignoreContent || '', CODER_GITIGNORE_BLOCK);
+        const nextGitignoreContent = appendBlock(currentGitignoreContent || '', buildCoderGitignoreBlock(missingRules));
         await promises.writeFile(gitignorePath, nextGitignoreContent, 'utf-8');
         return currentGitignoreContent === undefined ? 'created' : 'updated';
     }
     /**
-     * Detects whether `.gitignore` already covers the standalone coder temp directory.
+     * Returns the Promptbook coder gitignore rules that still need to be added.
      */
-    function hasTmpGitignoreRule(gitignoreContent) {
-        return /(^|[\r\n])\/?\.tmp(?:[\r\n]|$)/u.test(gitignoreContent);
+    function getMissingCoderGitignoreRules(gitignoreContent) {
+        const requiredRules = [CODER_TEMP_GITIGNORE_RULE, CODER_CACHE_GITIGNORE_RULE];
+        return requiredRules.filter((rule) => !hasGitignoreRule(gitignoreContent, rule));
+    }
+    /**
+     * Builds the Promptbook coder `.gitignore` block for the missing rules only.
+     */
+    function buildCoderGitignoreBlock(missingRules) {
+        return [CODER_GITIGNORE_HEADER, ...missingRules].join('\n');
+    }
+    /**
+     * Detects whether `.gitignore` already covers one exact rule.
+     */
+    function hasGitignoreRule(gitignoreContent, rule) {
+        const normalizedRulePattern = rule.startsWith('/')
+            ? `/?${escapeRegExp$1(rule.slice(1))}`
+            : escapeRegExp$1(rule);
+        return new RegExp(`(^|[\\r\\n])${normalizedRulePattern}(?:[\\r\\n]|$)`, 'u').test(gitignoreContent);
     }
     // Note: [🟡] Code for coder init gitignore bootstrapping [ensureCoderGitignoreFile](src/cli/cli-commands/coder/ensureCoderGitignoreFile.ts) should never be published outside of `@promptbook/cli`
 
@@ -2657,7 +2688,7 @@
                 ${typescript.flattenDiagnosticMessageText(parsedFile.error.messageText, '\n')}
             `));
         }
-        if (!isPlainObject(parsedFile.config)) {
+        if (!isPlainObject$1(parsedFile.config)) {
             throw new ParseError(_spaceTrim.spaceTrim(`
                 File \`${relativeFilePath}\` must contain one top-level JSON object.
             `));
@@ -2671,7 +2702,7 @@
         if (value === undefined) {
             return {};
         }
-        if (!isPlainObject(value)) {
+        if (!isPlainObject$1(value)) {
             throw new ParseError(_spaceTrim.spaceTrim(`
                 File \`${relativeFilePath}\` contains invalid \`${fieldPath}\`.
 
@@ -2716,7 +2747,7 @@
     /**
      * Checks whether one parsed JSON value is a plain object.
      */
-    function isPlainObject(value) {
+    function isPlainObject$1(value) {
         return typeof value === 'object' && value !== null && !Array.isArray(value);
     }
     // Note: [🟡] Code for coder init JSON merging [mergeStringRecordJsonFile](src/cli/cli-commands/coder/mergeStringRecordJsonFile.ts) should never be published outside of `@promptbook/cli`
@@ -6196,15 +6227,6 @@
     // TODO: [🧠][🈴] Where is the best location for this file
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
-    /**
-     * @@@
-     *
-     * @public exported from `@promptbook/utils`
-     */
-    function escapeRegExp$1(value) {
-        return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    }
-
     /**
      * HTTP header used by Promptbook clients to advertise their release version.
      *
@@ -43291,6 +43313,246 @@
     // TODO: Mirror from Collboard or some common package
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
+    /**
+     * Default file globs scanned for emoji tags.
+     */
+    const DEFAULT_INCLUDE_GLOBS = ['**/*.{ts,tsx,js,jsx,json,md,txt}'];
+    /**
+     * Default ignored paths while scanning the repository.
+     */
+    const DEFAULT_IGNORE_GLOBS = ['**/node_modules/**', '**/.git/**', '**/.promptbook/ptbk-coder/**'];
+    /**
+     * Directory used for Promptbook coder runtime caches.
+     */
+    const PTBK_CODER_CACHE_DIRECTORY_PATH = '.promptbook/ptbk-coder';
+    /**
+     * Relative cache file path storing per-file emoji-tag scan results.
+     */
+    const EMOJI_TAG_SCAN_CACHE_FILE_PATH = `${PTBK_CODER_CACHE_DIRECTORY_PATH}/emoji-tag-scan-cache.json`;
+    /**
+     * Current schema version of the persisted emoji-tag scan cache.
+     */
+    const EMOJI_TAG_SCAN_CACHE_VERSION = 1;
+    /**
+     * Scans repository files for bracketed emoji tags while reusing per-file cache entries for unchanged files.
+     */
+    async function scanEmojiTagUsage(options) {
+        var _a, _b, _c, _d;
+        const rootDir = (_a = options.rootDir) !== null && _a !== void 0 ? _a : process.cwd();
+        const includeGlobs = (_b = options.includeGlobs) !== null && _b !== void 0 ? _b : DEFAULT_INCLUDE_GLOBS;
+        const ignoreGlobs = (_c = options.ignoreGlobs) !== null && _c !== void 0 ? _c : DEFAULT_IGNORE_GLOBS;
+        const tagPrefix = (_d = options.tagPrefix) !== null && _d !== void 0 ? _d : '';
+        const filesToScan = await findFilesToScan(rootDir, includeGlobs, ignoreGlobs);
+        const matcher = buildEmojiTagMatcher(options.candidateEmojis, tagPrefix);
+        const usedEmojis = new Set();
+        const existingCache = await readEmojiTagScanCache(rootDir);
+        const nextCacheFiles = { ...existingCache.files };
+        let isCacheDirty = false;
+        let scannedFileCount = 0;
+        let reusedFileCount = 0;
+        for (const filePath of filesToScan) {
+            try {
+                const fileStats = fs.statSync(filePath);
+                const cacheKey = toCacheKey(rootDir, filePath);
+                const cachedFile = nextCacheFiles[cacheKey];
+                const cachedEmojis = getCachedFileEmojis(cachedFile, fileStats.mtimeMs, fileStats.size, tagPrefix);
+                if (cachedEmojis) {
+                    reusedFileCount += 1;
+                    addEmojis(usedEmojis, cachedEmojis);
+                    continue;
+                }
+                const fileContent = fs.readFileSync(filePath, 'utf-8'); /* Note: sync file reads are fine for local tooling. */
+                const scannedEmojis = scanFileForEmojiTags(fileContent, matcher);
+                addEmojis(usedEmojis, scannedEmojis);
+                nextCacheFiles[cacheKey] = updateCachedFile(cachedFile, fileStats.mtimeMs, fileStats.size, tagPrefix, scannedEmojis);
+                scannedFileCount += 1;
+                isCacheDirty = true;
+            }
+            catch (error) {
+                if (options.onFileError) {
+                    options.onFileError(normalizeError(error), filePath);
+                    continue;
+                }
+                throw error;
+            }
+        }
+        if (isCacheDirty) {
+            await writeEmojiTagScanCache(rootDir, {
+                version: EMOJI_TAG_SCAN_CACHE_VERSION,
+                files: nextCacheFiles,
+            });
+        }
+        return {
+            usedEmojis,
+            scannedFileCount,
+            reusedFileCount,
+        };
+    }
+    /**
+     * Resolves files to scan for matching emoji tags.
+     */
+    async function findFilesToScan(rootDir, includeGlobs, ignoreGlobs) {
+        const files = new Set();
+        for (const pattern of includeGlobs) {
+            const matches = await glob__default["default"](pattern, {
+                cwd: rootDir,
+                ignore: Array.from(new Set([...ignoreGlobs, ...DEFAULT_IGNORE_GLOBS])),
+                nodir: true,
+                absolute: true,
+            });
+            for (const match of matches) {
+                files.add(match);
+            }
+        }
+        return Array.from(files);
+    }
+    /**
+     * Builds a regex that matches one exact bracketed emoji-tag form.
+     */
+    function buildEmojiTagMatcher(candidateEmojis, tagPrefix) {
+        const escapedEmojiAlternatives = Array.from(candidateEmojis)
+            .sort((leftEmoji, rightEmoji) => rightEmoji.length - leftEmoji.length)
+            .map((emoji) => escapeRegExp$1(emoji))
+            .join('|');
+        if (escapedEmojiAlternatives === '') {
+            return /$^/u;
+        }
+        return new RegExp(`\\[${escapeRegExp$1(tagPrefix)}(?<emoji>${escapedEmojiAlternatives})\\]`, 'gu');
+    }
+    /**
+     * Extracts matching emojis from one file content.
+     */
+    function scanFileForEmojiTags(fileContent, matcher) {
+        var _a;
+        matcher.lastIndex = 0;
+        const matchedEmojis = new Set();
+        for (const match of fileContent.matchAll(matcher)) {
+            const emoji = (_a = match.groups) === null || _a === void 0 ? void 0 : _a.emoji;
+            if (emoji) {
+                matchedEmojis.add(emoji);
+            }
+        }
+        return Array.from(matchedEmojis);
+    }
+    /**
+     * Returns cached emojis when the file metadata still matches the stored cache entry.
+     */
+    function getCachedFileEmojis(cachedFile, mtimeMs, size, tagPrefix) {
+        if (!cachedFile || cachedFile.mtimeMs !== mtimeMs || cachedFile.size !== size) {
+            return undefined;
+        }
+        const cachedEmojis = cachedFile.tagsByPrefix[tagPrefix];
+        return Array.isArray(cachedEmojis) ? cachedEmojis : undefined;
+    }
+    /**
+     * Stores the latest scan result for one file while preserving other prefix caches when the file revision is unchanged.
+     */
+    function updateCachedFile(cachedFile, mtimeMs, size, tagPrefix, emojis) {
+        const isSameFileRevision = (cachedFile === null || cachedFile === void 0 ? void 0 : cachedFile.mtimeMs) === mtimeMs && cachedFile.size === size;
+        return {
+            mtimeMs,
+            size,
+            tagsByPrefix: {
+                ...(isSameFileRevision ? cachedFile.tagsByPrefix : {}),
+                [tagPrefix]: [...emojis],
+            },
+        };
+    }
+    /**
+     * Loads the persisted emoji-tag scan cache and falls back to an empty cache when it is missing or invalid.
+     */
+    async function readEmojiTagScanCache(rootDir) {
+        try {
+            const cacheContent = await promises.readFile(path.join(rootDir, EMOJI_TAG_SCAN_CACHE_FILE_PATH), 'utf-8');
+            return normalizeEmojiTagScanCache(JSON.parse(cacheContent));
+        }
+        catch (_a) {
+            return createEmptyEmojiTagScanCache();
+        }
+    }
+    /**
+     * Persists the updated emoji-tag scan cache as a best-effort optimization.
+     */
+    async function writeEmojiTagScanCache(rootDir, cache) {
+        try {
+            await promises.mkdir(path.join(rootDir, PTBK_CODER_CACHE_DIRECTORY_PATH), { recursive: true });
+            await promises.writeFile(path.join(rootDir, EMOJI_TAG_SCAN_CACHE_FILE_PATH), `${JSON.stringify(cache, null, 2)}\n`, 'utf-8');
+        }
+        catch (_a) {
+            // Note: Cache writes are only an optimization; scanning still succeeds when the cache cannot be written.
+        }
+    }
+    /**
+     * Normalizes one parsed cache payload into the current typed cache shape.
+     */
+    function normalizeEmojiTagScanCache(value) {
+        if (!isPlainObject(value) || value.version !== EMOJI_TAG_SCAN_CACHE_VERSION || !isPlainObject(value.files)) {
+            return createEmptyEmojiTagScanCache();
+        }
+        const files = {};
+        for (const [filePath, cachedValue] of Object.entries(value.files)) {
+            if (!isPlainObject(cachedValue)) {
+                continue;
+            }
+            const { mtimeMs, size, tagsByPrefix } = cachedValue;
+            if (typeof mtimeMs !== 'number' || typeof size !== 'number' || !isPlainObject(tagsByPrefix)) {
+                continue;
+            }
+            const normalizedTagsByPrefix = {};
+            for (const [tagPrefix, cachedEmojis] of Object.entries(tagsByPrefix)) {
+                if (!Array.isArray(cachedEmojis)) {
+                    continue;
+                }
+                normalizedTagsByPrefix[tagPrefix] = cachedEmojis.filter((emoji) => typeof emoji === 'string');
+            }
+            files[filePath] = {
+                mtimeMs,
+                size,
+                tagsByPrefix: normalizedTagsByPrefix,
+            };
+        }
+        return {
+            version: EMOJI_TAG_SCAN_CACHE_VERSION,
+            files,
+        };
+    }
+    /**
+     * Creates an empty cache payload for emoji-tag scans.
+     */
+    function createEmptyEmojiTagScanCache() {
+        return {
+            version: EMOJI_TAG_SCAN_CACHE_VERSION,
+            files: {},
+        };
+    }
+    /**
+     * Converts an absolute file path into a stable cache key relative to the scanned root.
+     */
+    function toCacheKey(rootDir, filePath) {
+        return path.relative(rootDir, filePath).replace(/\\/gu, '/');
+    }
+    /**
+     * Adds multiple emojis into one target set.
+     */
+    function addEmojis(target, emojis) {
+        for (const emoji of emojis) {
+            target.add(emoji);
+        }
+    }
+    /**
+     * Checks whether one unknown JSON value is a plain object.
+     */
+    function isPlainObject(value) {
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+    }
+    /**
+     * Normalizes thrown values into proper `Error` objects for optional callbacks.
+     */
+    function normalizeError(error) {
+        return error instanceof Error ? error : new Error(String(error));
+    }
+    // Note: [?] Code in this file should never be published in any package
+
     // find-fresh-emoji-tags.ts
     // Note: When run as a standalone script, call the exported function
     if (require.main === module) {
@@ -43320,29 +43582,16 @@
     async function findFreshEmojiTag() {
         initializeFindFreshEmojiTagRun();
         console.info(`🤪  Find fresh emoji tag`);
-        const allFiles = await glob__default["default"]('**/*.{ts,tsx,js,jsx,json,md,txt}', {
-            ignore: '**/node_modules/**', // <- TODO: [🚰] Ignore also hidden folders like *(`.promptbook`, `.next`, `.git`,...)*
-        });
         const allEmojis = EMOJIS_OF_SINGLE_PICTOGRAM;
-        // const allEmojis = new Set<string_char_emoji>(['🧎' as string_char_emoji, '🥎' as string_char_emoji]);
-        const usedEmojis = new Set();
-        for (const file of allFiles) {
-            try {
-                const content = fs.readFileSync(file, 'utf-8'); /* <- Note: Its OK to use sync in tooling for scripts */
-                for (const emoji of allEmojis) {
-                    const tag = `[${emoji}]`;
-                    if (content.includes(tag)) {
-                        usedEmojis.add(emoji);
-                    }
-                }
-            }
-            catch (error) {
-                console.error(colors__default["default"].red('Error in checking file file /' + file));
+        const { usedEmojis } = await scanEmojiTagUsage({
+            candidateEmojis: allEmojis,
+            tagPrefix: '',
+            onFileError: (error, filePath) => {
+                console.error(colors__default["default"].red('Error in checking file /' + filePath));
                 console.error(error);
-            }
-        }
-        //console.info({ usedEmojis });
-        const freshEmojis = difference(allEmojis, usedEmojis);
+            },
+        });
+        const freshEmojis = new Set(Array.from(allEmojis).filter((emoji) => !usedEmojis.has(emoji)));
         console.info(colors__default["default"].green(`Avialable fresh tags:`));
         const randomEmojis = [...$shuffleItems(...Array.from(freshEmojis))].splice(0, 10);
         // const randomEmojis = freshEmojis;
@@ -43950,9 +44199,14 @@
         const includeGlobs = (_b = options.includeGlobs) !== null && _b !== void 0 ? _b : ['**/*.{ts,tsx,js,jsx,json,md,txt}'];
         const ignoreGlobs = (_c = options.ignoreGlobs) !== null && _c !== void 0 ? _c : ['**/node_modules/**'];
         const tagPrefix = (_d = options.tagPrefix) !== null && _d !== void 0 ? _d : PROMPT_EMOJI_TAG_PREFIX;
-        const filesToScan = await findFilesToScan(rootDir, includeGlobs, ignoreGlobs);
-        const usedEmojis = collectUsedPromptEmojis(filesToScan, tagPrefix);
-        const freshEmojis = difference(EMOJIS_OF_SINGLE_PICTOGRAM, usedEmojis);
+        const { usedEmojis } = await scanEmojiTagUsage({
+            rootDir,
+            includeGlobs,
+            ignoreGlobs,
+            tagPrefix,
+            candidateEmojis: EMOJIS_OF_SINGLE_PICTOGRAM,
+        });
+        const freshEmojis = new Set(Array.from(EMOJIS_OF_SINGLE_PICTOGRAM).filter((emoji) => !usedEmojis.has(emoji)));
         const shuffledEmojis = $shuffleItems(...Array.from(freshEmojis));
         const selectedEmojis = shuffledEmojis.slice(0, count);
         if (selectedEmojis.length < count) {
@@ -43964,40 +44218,6 @@
             tagPrefix,
         };
     }
-    /**
-     * Resolves files to scan for existing prompt emoji tags.
-     */
-    async function findFilesToScan(rootDir, includeGlobs, ignoreGlobs) {
-        const files = new Set();
-        for (const pattern of includeGlobs) {
-            const matches = await glob__default["default"](pattern, {
-                cwd: rootDir,
-                ignore: ignoreGlobs,
-                nodir: true,
-                absolute: true,
-            });
-            for (const match of matches) {
-                files.add(match);
-            }
-        }
-        return Array.from(files);
-    }
-    /**
-     * Collects emojis already used with the configured prompt prefix.
-     */
-    function collectUsedPromptEmojis(filePaths, tagPrefix) {
-        const usedEmojis = new Set();
-        for (const file of filePaths) {
-            const content = fs.readFileSync(file, 'utf-8'); /* Note: sync read is fine for script tooling. */
-            for (const emoji of EMOJIS_OF_SINGLE_PICTOGRAM) {
-                const tag = formatPromptEmojiTag(emoji, tagPrefix);
-                if (content.includes(tag)) {
-                    usedEmojis.add(emoji);
-                }
-            }
-        }
-        return usedEmojis;
-    }
     // Note: [?] Code in this file should never be published in any package
 
     var promptEmojiTags = /*#__PURE__*/Object.freeze({
@@ -45026,6 +45246,27 @@
      * Current pause state.
      */
     let pauseState = 'RUNNING';
+    /**
+     * Stores one new pause state in the shared runner controller.
+     */
+    function setPauseState(nextPauseState) {
+        pauseState = nextPauseState;
+    }
+    /**
+     * Applies the same three-state toggle used by the `P` hotkey.
+     */
+    function togglePauseState() {
+        if (pauseState === 'RUNNING') {
+            setPauseState('PAUSING');
+            return 'REQUESTED_PAUSE';
+        }
+        if (pauseState === 'PAUSING') {
+            setPauseState('RUNNING');
+            return 'CANCELLED_PAUSE';
+        }
+        setPauseState('RUNNING');
+        return 'RESUMED';
+    }
     /**
      * Listens for the "p" key to pause and resume.
      */
@@ -45040,19 +45281,13 @@
                 process.exit();
             }
             if (key.name === 'p') {
-                if (pauseState === 'RUNNING') {
-                    pauseState = 'PAUSING';
+                const toggleResult = togglePauseState();
+                if (toggleResult === 'REQUESTED_PAUSE') {
                     // Note: Using console.log here which adds a new line.
                     // This is intentional to prevent the message from being overwritten.
                     console.log(colors__default["default"].bgWhite('Pausing...'));
                 }
-                else if (pauseState === 'PAUSED') {
-                    pauseState = 'RUNNING';
-                    // The checkPause loop will terminate.
-                }
-                else if (pauseState === 'PAUSING') {
-                    // If user presses 'p' again while pausing, cancel the pause.
-                    pauseState = 'RUNNING';
+                else if (toggleResult === 'CANCELLED_PAUSE') {
                     console.log(colors__default["default"].green('Pause cancelled. Resuming...'));
                 }
             }
@@ -45068,12 +45303,12 @@
     async function checkPause(options) {
         var _a, _b;
         if (pauseState === 'PAUSING') {
-            pauseState = 'PAUSED';
+            setPauseState('PAUSED');
             if (!(options === null || options === void 0 ? void 0 : options.silent)) {
                 console.log(colors__default["default"].bgWhite.black('Paused') + colors__default["default"].gray(' (Press "p" to resume)'));
             }
             (_a = options === null || options === void 0 ? void 0 : options.onPaused) === null || _a === void 0 ? void 0 : _a.call(options);
-            while (pauseState === 'PAUSED') {
+            while (getPauseState() === 'PAUSED') {
                 await new Promise((resolve) => setTimeout(resolve, 100));
             }
             (_b = options === null || options === void 0 ? void 0 : options.onResumed) === null || _b === void 0 ? void 0 : _b.call(options);
@@ -45088,20 +45323,6 @@
     function getPauseState() {
         return pauseState;
     }
-    /**
-     * Requests a pause from an external controller (e.g. the Ink UI).
-     */
-    function requestPause() {
-        if (pauseState === 'RUNNING') {
-            pauseState = 'PAUSING';
-        }
-    }
-    /**
-     * Resumes execution from an external controller after a pause.
-     */
-    function requestResume() {
-        pauseState = 'RUNNING';
-    }
 
     /**
      * Environment variable that configures the name used for agent commits.
@@ -45446,7 +45667,8 @@
 
     /**
      * Commits staged changes with the provided message using the dedicated coding-agent identity when configured,
-     * otherwise falls back to the default Git configuration. Remote pushing is opt-in via `options.autoPush`.
+     * otherwise falls back to the default Git configuration. Remote pushing is opt-in via `options.autoPush`,
+     * while `options.excludePaths` can keep temporary artifacts out of the created commit.
      */
     async function commitChanges(message, options) {
         const projectPath = process.cwd();
@@ -45456,11 +45678,7 @@
         try {
             const agentEnv = buildAgentGitEnv();
             const signingFlag = buildAgentGitSigningFlag();
-            await runGitCommand({
-                command: 'git add .',
-                cwd: projectPath,
-                env: agentEnv,
-            });
+            await stageCommitChanges(projectPath, agentEnv, options === null || options === void 0 ? void 0 : options.excludePaths);
             await runGitCommand({
                 command: buildGitCommitCommand(commitMessagePath, signingFlag),
                 cwd: projectPath,
@@ -45474,6 +45692,56 @@
             await promises.unlink(commitMessagePath).catch(() => undefined);
         }
     }
+    /**
+     * Stages repository changes and optionally unstages temporary files that should not end up inside the commit.
+     */
+    async function stageCommitChanges(projectPath, agentEnv, excludePaths) {
+        await runGitCommand({
+            command: 'git add .',
+            cwd: projectPath,
+            env: agentEnv,
+        });
+        const excludedGitPaths = normalizeExcludedGitPaths(projectPath, excludePaths);
+        if (excludedGitPaths.length === 0) {
+            return;
+        }
+        await runGitCommand({
+            command: `git reset --quiet HEAD -- ${excludedGitPaths.map(quoteShellPath).join(' ')}`,
+            cwd: projectPath,
+            env: agentEnv,
+            isVerbose: false,
+        });
+    }
+    /**
+     * Converts excluded filesystem paths into unique repository-relative Git paths.
+     */
+    function normalizeExcludedGitPaths(projectPath, excludePaths) {
+        if (!excludePaths || excludePaths.length === 0) {
+            return [];
+        }
+        return [
+            ...new Set(excludePaths
+                .map((excludePath) => normalizeExcludedGitPath(projectPath, excludePath))
+                .filter((gitPath) => Boolean(gitPath))),
+        ];
+    }
+    /**
+     * Converts one excluded filesystem path into a Git-friendly repository-relative path.
+     */
+    function normalizeExcludedGitPath(projectPath, excludePath) {
+        const absoluteExcludePath = path.resolve(projectPath, excludePath);
+        const relativeExcludePath = path.relative(projectPath, absoluteExcludePath).replace(/\\/gu, '/');
+        if (relativeExcludePath === '' || relativeExcludePath === '.' || relativeExcludePath.startsWith('../')) {
+            return undefined;
+        }
+        return relativeExcludePath;
+    }
+    /**
+     * Quotes one Git path for safe shell execution.
+     */
+    function quoteShellPath(path) {
+        return JSON.stringify(path);
+    }
     /**
      * Branded error used when pushing committed changes fails.
      */
@@ -48694,49 +48962,215 @@ bash "$1"
         return `${scriptPath}.test.sh`;
     }
 
+    /**
+     * Centers an ANSI-colored line within the available frame width.
+     *
+     * @private internal utility of coder run UI
+     */
+    function centerAnsiText(text, width) {
+        const paddingWidth = Math.max(0, Math.floor((width - visibleLength(text)) / 2));
+        return `${' '.repeat(paddingWidth)}${text}`;
+    }
+    /**
+     * Pads or truncates a possibly ANSI-colored line to the target visible width.
+     *
+     * @private internal utility of coder run UI
+     */
+    function padAnsiText(text, width) {
+        const fittedText = fitAnsiText(text, width);
+        return fittedText + ' '.repeat(Math.max(0, width - visibleLength(fittedText)));
+    }
+    /**
+     * Truncates a possibly ANSI-colored line to the target visible width.
+     *
+     * @private internal utility of coder run UI
+     */
+    function fitAnsiText(text, width) {
+        if (visibleLength(text) <= width) {
+            return text;
+        }
+        return fitPlainText(stripAnsi(text), width);
+    }
+    /**
+     * Truncates a plain-text line to the target width with an ellipsis.
+     *
+     * @private internal utility of coder run UI
+     */
+    function fitPlainText(text, width) {
+        if (text.length <= width) {
+            return text;
+        }
+        if (width <= 3) {
+            return '.'.repeat(width);
+        }
+        return `${text.slice(0, width - 3)}...`;
+    }
+    /**
+     * Measures visible string width by stripping ANSI escape codes.
+     *
+     * @private internal utility of coder run UI
+     */
+    function visibleLength(text) {
+        return stripAnsi(text).length;
+    }
+    /**
+     * Strips ANSI escape codes from a string.
+     *
+     * @private internal utility of coder run UI
+     */
+    function stripAnsi(text) {
+        // eslint-disable-next-line no-control-regex
+        return text.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+    }
+
+    /**
+     * Fixed left-side head used across all octopus frames.
+     */
+    const OCTOPUS_HEAD_LINES = [
+        colors__default["default"].magenta.bold('      .-""""-.'),
+        colors__default["default"].magenta.bold("    .'  .-.  '."),
+        `${colors__default["default"].magenta.bold('   /   (')}${colors__default["default"].yellow.bold('o o')}${colors__default["default"].magenta.bold(')   \\')}`,
+        colors__default["default"].magenta.bold('  |      ^      |'),
+        colors__default["default"].magenta.bold('  |   \\___/     |'),
+        colors__default["default"].magenta.bold('   \\___________/'),
+    ];
+    /**
+     * Gap between the head silhouette and the animated tentacles.
+     */
+    const OCTOPUS_HEAD_TO_TENTACLE_GAP = '   ';
+    /**
+     * Animated right-side tentacle poses.
+     */
+    const OCTOPUS_TENTACLE_FRAMES = [
+        [
+            `                 ${colors__default["default"].green.bold('ptbk.io')}`,
+            colors__default["default"].cyan('          __      __'),
+            colors__default["default"].cyan('   _/\\/\\/  \\_/\\/  \\_/\\_'),
+            colors__default["default"].cyan('_/\\/  _   /\\/  _  /\\/\\__'),
+            colors__default["default"].cyan('\\__/ /_/\\/  \\_/ \\_/  \\_/'),
+            colors__default["default"].cyan('   /_/   \\__/   \\__/  /'),
+        ],
+        [
+            `                 ${colors__default["default"].green.bold('ptbk.io')}`,
+            colors__default["default"].cyan('          __      __'),
+            colors__default["default"].cyan('   _/\\/  \\_/\\/\\_  \\_/\\_'),
+            colors__default["default"].cyan('_/\\/  _  /\\/  _ \\/\\/  \\__'),
+            colors__default["default"].cyan('\\__/ /_/\\/  \\_/  \\_ /\\_/'),
+            colors__default["default"].cyan('     /_/  \\__/   \\__/  /'),
+        ],
+        [
+            `                 ${colors__default["default"].green.bold('ptbk.io')}`,
+            colors__default["default"].cyan('          __      __'),
+            colors__default["default"].cyan('   _/\\/\\/  \\_/\\_  \\_/\\_'),
+            colors__default["default"].cyan('_/\\/  _   /\\/  _  /\\/  \\_'),
+            colors__default["default"].cyan('\\__/ /_/\\/  \\_/ \\_/  _/'),
+            colors__default["default"].cyan('   /_/    \\__/    \\__/'),
+        ],
+        [
+            `                 ${colors__default["default"].green.bold('ptbk.io')}`,
+            colors__default["default"].cyan('          __      __'),
+            colors__default["default"].cyan('   _/\\/  \\_/\\/  \\_/\\/\\_'),
+            colors__default["default"].cyan('_/\\/  _  /\\/  _  /\\/\\  \\'),
+            colors__default["default"].cyan('\\__/ /_/\\/  \\_/ \\_  \\_/'),
+            colors__default["default"].cyan('    /_/   \\__/   \\__\\_/'),
+        ],
+    ];
+    /**
+     * Builds the horizontal octopus illustration shown above the coder-run dashboard.
+     *
+     * @private internal utility of coder run UI
+     */
+    function buildCoderRunOctopusVisual(options) {
+        const tentacleFrame = OCTOPUS_TENTACLE_FRAMES[((options.animationFrame % OCTOPUS_TENTACLE_FRAMES.length) + OCTOPUS_TENTACLE_FRAMES.length) %
+            OCTOPUS_TENTACLE_FRAMES.length];
+        const visualLines = OCTOPUS_HEAD_LINES.map((headLine, lineIndex) => `${headLine}${OCTOPUS_HEAD_TO_TENTACLE_GAP}${tentacleFrame[lineIndex]}`);
+        const visualWidth = visualLines.reduce((maxWidth, line) => Math.max(maxWidth, visibleLength(line)), 0);
+        visualLines.map((line) => centerAnsiText(padAnsiText(line, visualWidth), options.totalWidth));
+        /*
+        Note: Octopus art should look better, now using just text
+        https://www.google.com/search?sca_esv=52e84acb78c558cc&sxsrf=ANbL-n7DVKf71T1HSPRpM-2skfMss0jh7w:1776693767588&udm=2&fbs=ADc_l-ZseckkBJUFopaGDNYa-HGjo4_b6b_a7pIHTL5Y9QnExg6xJqXbG7aOLcH8CWqOtkzCrjxXWZVmrIhYPvZzFDVUIb7oTJfuJ6idsCc5GA1j5KGoi2q3sW0uDBWWfYgbuxGWTQPZMetvj33BdP833wZm47mxW-6rC3bTQWluwJdOsgloPieyQvTfF2uNgIZ_K0KZ-WzpL1An8GuRrKqHdvl8T306FA&q=octopus&sa=X&ved=2ahUKEwil7ZCHzPyTAxUghP0HHY-_Js8QtKgLegQIOhAB&biw=1745&bih=903&dpr=1.1#sv=CAMSVhoyKhBlLVl1bHNmeVhneml6a1dNMg5ZdWxzZnlYZ3ppemtXTToOTVJvdXhTdk5STkZ4d00gBCocCgZtb3NhaWMSEGUtWXVsc2Z5WGd6aXprV00YADABGAcg46LBxA9KCBABGAEgASgB
+        https://www.mrgoodfish.com/wp-content/uploads/2022/09/Eledone_moschata__.png
+        https://fish-commercial-names.ec.europa.eu/fish-names/jakarta.faces.resource/pictograms/octopus_vulgaris.jpg.xhtml?ln=images
+        https://www.asciiart.eu/image-to-ascii
+        */
+        // Note: Created by https://patorjk.com/software/taag/#p=display&f=ANSI+Compact&t=ptbk.io&x=none&v=4&h=4&w=80&we=false
+        return _spaceTrim__default["default"](`                        
+                                   
+        ▄▄▄▄ ▄▄▄▄▄▄ ▄▄▄▄  ▄▄ ▄▄   ▄▄  ▄▄▄  
+        ██▄█▀  ██   ██▄██ ██▄█▀   ██ ██▀██ 
+        ██     ██   ██▄█▀ ██ ██ ▄ ██ ▀███▀ 
+                                            
+    `)
+            .split('\n')
+            .map((line) => centerAnsiText(line, options.totalWidth));
+    }
+
+    /**
+     * Refresh cadence used only while the rich coder UI needs animated updates.
+     *
+     * @private internal constant of coder run UI
+     */
+    const ACTIVE_CODER_RUN_UI_REFRESH_INTERVAL_MS = 300;
+    /**
+     * Phases that still benefit from automatic refreshes because the frame can change
+     * over time even without new runner output.
+     *
+     * @private internal constant of coder run UI
+     */
+    const AUTO_REFRESH_PHASES = ['initializing', 'loading', 'running', 'verifying'];
+    /**
+     * Returns whether the rich coder UI should keep animating on its own.
+     *
+     * @private internal utility of coder run UI
+     */
+    function isCoderRunUiAutoRefreshing(phase, pauseState) {
+        // `PAUSING` still means the current task is winding down, so keep active
+        // animations/timers running until the runner reaches the fully paused state.
+        if (pauseState === 'PAUSED') {
+            return false;
+        }
+        return AUTO_REFRESH_PHASES.includes(phase);
+    }
+    /**
+     * Returns the automatic refresh interval for the current UI state.
+     *
+     * Waiting, paused, and completed states return `undefined` so the rich UI stays
+     * perfectly still until actual state changes arrive.
+     *
+     * @private internal utility of coder run UI
+     */
+    function getCoderRunUiAutoRefreshInterval(phase, pauseState) {
+        return isCoderRunUiAutoRefreshing(phase, pauseState) ? ACTIVE_CODER_RUN_UI_REFRESH_INTERVAL_MS : undefined;
+    }
+
     /**
      * Maximum number of output lines reserved for agent output in the UI.
      */
     const MAX_VISIBLE_OUTPUT_LINES = 8;
+    /**
+     * Minimum width used for the rich coder-run frame.
+     */
+    const MIN_FRAME_WIDTH = 56;
+    /**
+     * Maximum width used for the rich coder-run frame.
+     */
+    const MAX_FRAME_WIDTH = 96;
+    /**
+     * Visible width reserved for aligned labels in the session box.
+     */
+    const SESSION_LABEL_WIDTH = 8;
     /**
      * Builds the complete boxed terminal frame for the rich `ptbk coder run` UI.
      */
     function buildCoderRunUiFrame(options) {
-        const totalWidth = Math.max(56, Math.min(options.terminalWidth, 96));
+        const totalWidth = Math.max(MIN_FRAME_WIDTH, Math.min(options.terminalWidth, MAX_FRAME_WIDTH));
         const isPromptActive = options.phase === 'running' || options.phase === 'verifying' || options.phase === 'loading';
         const promptStatusPrefix = isPromptActive ? `${colors__default["default"].yellow(`${options.spinner} `)}` : '';
-        const sessionScopeLine = options.progress.sessionTotal > 0
-            ? `Working on ${options.progress.currentPromptIndex}/${options.progress.sessionTotal} prompts with Priority ≥${options.config.priority}`
-            : `No runnable prompts with Priority ≥${options.config.priority}`;
-        const sessionCountLine = `Done ${options.progress.sessionDone}/${options.progress.sessionTotal} this run  ·  Repo total ${options.progress.totalPrompts}`;
-        const sessionQueueParts = [];
-        if (options.progress.skippedPrompts > 0) {
-            sessionQueueParts.push(`Skipping ${formatPromptCount(options.progress.skippedPrompts)} with Priority <${options.config.priority}`);
-        }
-        if (options.progress.toBeWrittenPrompts > 0) {
-            sessionQueueParts.push(`Write first ${formatPromptCount(options.progress.toBeWrittenPrompts)}`);
-        }
-        const sessionLines = [
-            `${buildPhaseBadge(options.phase, options.pauseState)} ${fitPlainText(options.statusMessage, totalWidth - 18)}`,
-            sessionScopeLine,
-            sessionCountLine,
-            ...(sessionQueueParts.length > 0 ? [sessionQueueParts.join('  ·  ')] : []),
-            `Elapsed ${options.progress.elapsedText}  ·  Est. total ${options.progress.estimatedTotalText}  ·  Est. done ${options.progress.estimatedLabel}`,
-            buildProgressBar(options.progress.percentage, totalWidth - 6, `${options.progress.percentage}% complete (${options.progress.sessionDone}/${options.progress.sessionTotal} done)`),
-        ];
-        const metadataParts = [options.config.agentName || 'No agent selected'];
-        if (options.config.modelName) {
-            metadataParts.push(options.config.modelName);
-        }
-        if (options.config.thinkingLevel) {
-            metadataParts.push(`thinking ${options.config.thinkingLevel}`);
-        }
-        const runnerDetails = [
-            [`${colors__default["default"].bgCyan.black(' PTBK ')}`, colors__default["default"].bgBlue.white(' CODER '), colors__default["default"].bold.white(' Promptbook Coder')]
-                .join(''),
-            metadataParts.join('  ·  '),
-            buildConfigSummaryLine(options.config),
-        ];
+        const octopusAnimationFrame = isCoderRunUiAutoRefreshing(options.phase, options.pauseState)
+            ? options.animationFrame
+            : 0;
+        const pausePresentation = buildPausePresentation(options.phase, options.pauseState, options.statusMessage);
+        const sessionLines = buildSessionLines(options, totalWidth, pausePresentation);
         const currentTaskLines = options.currentPromptLabel
             ? [
                 `${promptStatusPrefix}${colors__default["default"].bold.white(fitPlainText(options.currentPromptLabel, totalWidth - 8))}`,
@@ -48744,12 +49178,11 @@ bash "$1"
                 ...options.detailLines.map((detailLine) => `• ${detailLine}`),
             ]
             : [options.statusMessage, ...options.detailLines.map((detailLine) => `• ${detailLine}`)];
-        const visibleOutputLines = options.agentOutputLines.length > 0
-            ? options.agentOutputLines.slice(-MAX_VISIBLE_OUTPUT_LINES).map((line) => `› ${stripAnsi(line)}`)
-            : ['No live agent output yet.'];
-        const controls = buildControlPills(options.pauseState, options.pendingEnterLabel).join('  ');
+        const visibleOutputLines = buildVisibleOutputLines(options.agentOutputLines);
+        const controls = buildControlPills(pausePresentation.pauseControl, options.pendingEnterLabel).join('  ');
         const frame = [
-            ...renderBox('Brand', runnerDetails, totalWidth, colors__default["default"].cyan.bold),
+            ...buildCoderRunOctopusVisual({ totalWidth, animationFrame: octopusAnimationFrame }),
+            '',
             ...renderBox('Session', sessionLines, totalWidth, colors__default["default"].yellow.bold),
             ...renderBox(options.currentPromptLabel ? 'Current task' : 'Queue', currentTaskLines, totalWidth, colors__default["default"].magenta.bold),
             ...renderBox('Live output', visibleOutputLines, totalWidth, colors__default["default"].green.bold),
@@ -48760,6 +49193,72 @@ bash "$1"
         frame.push(...renderBox('Controls', [controls], totalWidth, colors__default["default"].white.bold));
         return frame;
     }
+    /**
+     * Builds the structured session lines that combine state, runner, queue, and timing metadata.
+     */
+    function buildSessionLines(options, totalWidth, pausePresentation) {
+        const bodyWidth = Math.max(10, totalWidth - 4);
+        return buildSessionRows(options, bodyWidth, pausePresentation).map((sessionRow) => buildLabeledSessionLine(sessionRow.label, sessionRow.value, bodyWidth));
+    }
+    /**
+     * Builds the session rows so the renderer can keep one consistent structure without duplicating labels.
+     */
+    function buildSessionRows(options, bodyWidth, pausePresentation) {
+        const runnerParts = [options.config.agentName || 'No agent selected'];
+        if (options.config.modelName) {
+            runnerParts.push(options.config.modelName);
+        }
+        if (options.config.thinkingLevel) {
+            runnerParts.push(`thinking ${options.config.thinkingLevel}`);
+        }
+        const configurationRows = [
+            ...buildOptionalSessionRow('Context', options.config.context),
+            ...buildOptionalSessionRow('Test', options.config.testCommand),
+        ];
+        return [
+            {
+                label: 'State',
+                value: `${pausePresentation.badge} ${pausePresentation.stateMessage}`,
+            },
+            {
+                label: 'Runner',
+                value: runnerParts.join('  ·  '),
+            },
+            ...configurationRows,
+            {
+                label: 'This run',
+                value: buildThisRunSummary(options.progress),
+            },
+            {
+                label: 'Backlog',
+                value: buildBacklogSummary(options.progress),
+            },
+            {
+                label: 'Scope',
+                value: buildScopeSummary(options.progress, options.config),
+            },
+            {
+                label: 'Timing',
+                value: buildTimingSummary(options.progress),
+            },
+            {
+                label: 'Progress',
+                value: buildProgressBar(options.progress.percentage, bodyWidth - SESSION_LABEL_WIDTH - 1, `${options.progress.percentage}% complete (${options.progress.sessionDone}/${options.progress.sessionTotal} done)`),
+            },
+        ];
+    }
+    /**
+     * Builds the fixed-height live output section so streaming updates do not keep resizing the frame.
+     */
+    function buildVisibleOutputLines(agentOutputLines) {
+        const visibleOutputLines = agentOutputLines.length > 0
+            ? agentOutputLines.slice(-MAX_VISIBLE_OUTPUT_LINES).map((line) => `› ${stripAnsi(line)}`)
+            : [colors__default["default"].gray('No live agent output yet.')];
+        while (visibleOutputLines.length < MAX_VISIBLE_OUTPUT_LINES) {
+            visibleOutputLines.push('');
+        }
+        return visibleOutputLines;
+    }
     /**
      * Renders a framed box with a colored title and padded body lines.
      */
@@ -48777,25 +49276,84 @@ bash "$1"
         return [topBorder, ...body, bottomBorder];
     }
     /**
-     * Builds the compact config summary line shown in the branding box.
+     * Builds one aligned labeled line inside the session box.
      */
-    function buildConfigSummaryLine(config) {
-        const parts = [`Priority ≥${config.priority}`];
-        if (config.context) {
-            parts.unshift(`Context ${config.context}`);
+    function buildLabeledSessionLine(label, value, bodyWidth) {
+        const formattedLabel = colors__default["default"].gray(label.padEnd(SESSION_LABEL_WIDTH));
+        return `${formattedLabel} ${fitAnsiText(value, bodyWidth - SESSION_LABEL_WIDTH - 1)}`;
+    }
+    /**
+     * Builds zero or one structured session row for optional metadata.
+     */
+    function buildOptionalSessionRow(label, value) {
+        if (!value) {
+            return [];
         }
-        if (config.testCommand) {
-            parts.push(`Test ${config.testCommand}`);
+        return [{ label, value }];
+    }
+    /**
+     * Builds the active-session summary shown in the session box.
+     */
+    function buildThisRunSummary(progress) {
+        if (progress.sessionTotal === 0) {
+            return 'No runnable prompts in current scope';
+        }
+        return `Task ${progress.currentPromptIndex}/${progress.sessionTotal}  ·  ${progress.sessionDone} done  ·  ${progress.sessionRemaining} left`;
+    }
+    /**
+     * Builds the backlog/filter summary shown in the session box.
+     */
+    function buildBacklogSummary(progress) {
+        const parts = [`Repo ${progress.totalPrompts} total`];
+        if (progress.skippedPrompts > 0) {
+            parts.push(`${formatPromptCount(progress.skippedPrompts)} below priority`);
         }
         return parts.join('  ·  ');
     }
+    /**
+     * Builds the priority/write-order summary shown in the session box.
+     */
+    function buildScopeSummary(progress, config) {
+        const parts = [`Priority ≥${config.priority}`];
+        if (progress.toBeWrittenPrompts > 0) {
+            parts.push(`Write ${formatPromptCount(progress.toBeWrittenPrompts)} first`);
+        }
+        return parts.join('  ·  ');
+    }
+    /**
+     * Builds the elapsed/estimate summary shown in the session box.
+     */
+    function buildTimingSummary(progress) {
+        return `Elapsed ${progress.elapsedText}  ·  Total ${progress.estimatedTotalText}  ·  ETA ${progress.estimatedLabel}`;
+    }
     /**
      * Builds the colored phase badge shown in the session box.
      */
-    function buildPhaseBadge(phase, pauseState) {
-        if (pauseState !== 'RUNNING' || phase === 'paused') {
-            return colors__default["default"].bgYellow.black(' PAUSED ');
+    function buildPausePresentation(phase, pauseState, statusMessage) {
+        if (pauseState === 'PAUSING') {
+            return {
+                badge: colors__default["default"].bgYellow.black(' PAUSING '),
+                stateMessage: 'Pausing before the next task',
+                pauseControl: colors__default["default"].bgMagenta.white(' P ') + colors__default["default"].white(' Cancel pause'),
+            };
+        }
+        if (pauseState === 'PAUSED') {
+            return {
+                badge: colors__default["default"].bgWhite.black(' PAUSED '),
+                stateMessage: 'Paused until resumed',
+                pauseControl: colors__default["default"].bgGreen.black(' P ') + colors__default["default"].white(' Resume'),
+            };
         }
+        return {
+            badge: buildRunningPhaseBadge(phase),
+            stateMessage: statusMessage,
+            pauseControl: colors__default["default"].bgYellow.black(' P ') + colors__default["default"].white(' Pause'),
+        };
+    }
+    /**
+     * Builds the active phase badge shown in the session box while the runner is not paused.
+     */
+    function buildRunningPhaseBadge(phase) {
         switch (phase) {
             case 'loading':
             case 'initializing':
@@ -48810,6 +49368,8 @@ bash "$1"
                 return colors__default["default"].bgGreen.black(' DONE ');
             case 'error':
                 return colors__default["default"].bgRed.white(' ERROR ');
+            case 'paused':
+                return colors__default["default"].bgWhite.black(' READY ');
             default:
                 return colors__default["default"].bgWhite.black(' READY ');
         }
@@ -48822,7 +49382,7 @@ bash "$1"
         const barWidth = Math.max(10, availableWidth - percentageLabel.length - 1);
         const filledWidth = Math.round((percentage / 100) * barWidth);
         const emptyWidth = Math.max(0, barWidth - filledWidth);
-        return `${colors__default["default"].green('█'.repeat(filledWidth))}${colors__default["default"].gray('░'.repeat(emptyWidth))} ${percentageLabel}`;
+        return `${colors__default["default"].green('█'.repeat(filledWidth))}${colors__default["default"].blue('░'.repeat(emptyWidth))} ${percentageLabel}`;
     }
     /**
      * Formats a prompt count with singular/plural wording.
@@ -48833,58 +49393,15 @@ bash "$1"
     /**
      * Builds the control pills shown in the footer box.
      */
-    function buildControlPills(pauseState, pendingEnterLabel) {
+    function buildControlPills(pauseControl, pendingEnterLabel) {
         const pills = [];
         if (pendingEnterLabel) {
             pills.push(colors__default["default"].bgWhite.black(' ENTER ') + colors__default["default"].white(` ${pendingEnterLabel}`));
         }
-        pills.push(pauseState === 'RUNNING'
-            ? colors__default["default"].bgYellow.black(' P ') + colors__default["default"].white(' Pause')
-            : colors__default["default"].bgYellow.black(' P ') + colors__default["default"].white(' Resume'));
+        pills.push(pauseControl);
         pills.push(colors__default["default"].bgRed.white(' CTRL+C ') + colors__default["default"].white(' Exit'));
         return pills;
     }
-    /**
-     * Pads or truncates a possibly ANSI-colored line to the target visible width.
-     */
-    function padAnsiText(text, width) {
-        const fittedText = fitAnsiText(text, width);
-        return fittedText + ' '.repeat(Math.max(0, width - visibleLength(fittedText)));
-    }
-    /**
-     * Truncates a possibly ANSI-colored line to the target visible width.
-     */
-    function fitAnsiText(text, width) {
-        if (visibleLength(text) <= width) {
-            return text;
-        }
-        return fitPlainText(stripAnsi(text), width);
-    }
-    /**
-     * Truncates a plain-text line to the target width with an ellipsis.
-     */
-    function fitPlainText(text, width) {
-        if (text.length <= width) {
-            return text;
-        }
-        if (width <= 3) {
-            return '.'.repeat(width);
-        }
-        return `${text.slice(0, width - 3)}...`;
-    }
-    /**
-     * Measures visible string width by stripping ANSI escape codes.
-     */
-    function visibleLength(text) {
-        return stripAnsi(text).length;
-    }
-    /**
-     * Strips ANSI escape codes from a string.
-     */
-    function stripAnsi(text) {
-        // eslint-disable-next-line no-control-regex
-        return text.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
-    }
 
     /**
      * Maximum number of agent output lines kept in the scrolling output area.
@@ -49025,12 +49542,6 @@ bash "$1"
         }
     }
 
-    /**
-     * Refresh interval for the terminal UI in milliseconds.
-     *
-     * @private internal constant of coder run UI
-     */
-    const UI_REFRESH_INTERVAL_MS = 200;
     /**
      * Spinner animation frames.
      *
@@ -49059,9 +49570,10 @@ bash "$1"
     /**
      * Boots the ANSI terminal UI for `ptbk coder run`.
      *
-     * The UI reserves a fixed number of terminal lines and repaints them periodically.
-     * Between repaints, any console output from runners is captured and fed into the
-     * scrolling agent-output area.
+     * The UI reserves a fixed number of terminal lines and refreshes them incrementally.
+     * While a prompt is actively running, it schedules lightweight timed refreshes for
+     * the spinner/progress area; otherwise it redraws only when real state changes arrive.
+     * Any console output from runners is captured and fed into the scrolling agent-output area.
      *
      * On non-interactive (non-TTY) terminals the UI is skipped entirely and
      * only the state object is provided.
@@ -49111,72 +49623,140 @@ bash "$1"
             process.stdin.setRawMode(true);
         }
         let spinnerFrame = 0;
-        let previousFrameLineCount = 0;
+        let previousFrameLines = [];
         let isRendering = false;
         let renderScheduled = false;
+        let autoRefreshTimeout;
+        let isDisposed = false;
         /**
          * Schedules a render on the next tick if one isn't already pending.
          * Prevents overlapping renders that cause cursor desync.
          */
         function scheduleRender() {
-            if (renderScheduled) {
+            if (renderScheduled || isDisposed) {
                 return;
             }
             renderScheduled = true;
             setImmediate(() => {
                 renderScheduled = false;
+                if (isDisposed) {
+                    return;
+                }
                 render();
             });
         }
         /**
-         * Clears previously rendered lines and writes a new frame.
+         * Re-schedules automatic animation refreshes only while the frame can change by itself.
+         */
+        function scheduleAutoRefresh() {
+            if (autoRefreshTimeout) {
+                clearTimeout(autoRefreshTimeout);
+                autoRefreshTimeout = undefined;
+            }
+            const autoRefreshInterval = getCoderRunUiAutoRefreshInterval(state.phase, getPauseState());
+            if (autoRefreshInterval === undefined) {
+                return;
+            }
+            autoRefreshTimeout = setTimeout(() => {
+                autoRefreshTimeout = undefined;
+                scheduleRender();
+            }, autoRefreshInterval);
+        }
+        /**
+         * Moves the cursor relative to the bottom of the current frame and rewrites one line in place.
+         */
+        function rewriteFrameLine(frameLineCount, lineIndex, line) {
+            const linesUpFromBottom = Math.max(0, frameLineCount - 1 - lineIndex);
+            if (linesUpFromBottom > 0) {
+                process.stdout.write(`\x1b[${linesUpFromBottom}A`);
+            }
+            readline.clearLine(process.stdout, 0);
+            readline.cursorTo(process.stdout, 0);
+            process.stdout.write(line);
+            readline.cursorTo(process.stdout, 0);
+            if (linesUpFromBottom > 0) {
+                process.stdout.write(`\x1b[${linesUpFromBottom}B`);
+                readline.cursorTo(process.stdout, 0);
+            }
+        }
+        /**
+         * Fully rewrites the reserved frame area.
+         */
+        function renderFullFrame(lines) {
+            var _a;
+            const previousFrameLineCount = previousFrameLines.length;
+            const linesToRewriteCount = Math.max(previousFrameLineCount, lines.length);
+            if (previousFrameLineCount > 1) {
+                process.stdout.write(`\x1b[${previousFrameLineCount - 1}A`);
+            }
+            for (let i = 0; i < linesToRewriteCount; i++) {
+                readline.clearLine(process.stdout, 0);
+                readline.cursorTo(process.stdout, 0);
+                process.stdout.write((_a = lines[i]) !== null && _a !== void 0 ? _a : '');
+                if (i < linesToRewriteCount - 1) {
+                    process.stdout.write('\n');
+                }
+            }
+            const clearedTrailingLines = linesToRewriteCount - lines.length;
+            if (clearedTrailingLines > 0) {
+                process.stdout.write(`\x1b[${clearedTrailingLines}A`);
+            }
+            readline.cursorTo(process.stdout, 0);
+        }
+        /**
+         * Updates only the frame rows whose visible content changed.
+         */
+        function renderChangedLines(lines) {
+            for (let i = 0; i < lines.length; i++) {
+                if (previousFrameLines[i] === lines[i]) {
+                    continue;
+                }
+                rewriteFrameLine(lines.length, i, lines[i]);
+            }
+        }
+        /**
+         * Builds the current frame snapshot from the latest state.
+         */
+        function buildFrameLines() {
+            return buildCoderRunUiFrame({
+                terminalWidth: getTerminalWidth(),
+                animationFrame: spinnerFrame,
+                spinner: SPINNER_FRAMES[spinnerFrame],
+                pauseState: getPauseState(),
+                config: state.config,
+                phase: state.phase,
+                currentPromptLabel: state.currentPromptLabel,
+                currentAttempt: state.currentAttempt,
+                maxAttempts: state.maxAttempts,
+                statusMessage: state.statusMessage,
+                detailLines: state.detailLines,
+                pendingEnterLabel: state.pendingEnterLabel,
+                agentOutputLines: state.agentOutputLines,
+                errors: state.errors,
+                progress: state.getProgress(),
+            });
+        }
+        /**
+         * Clears previously rendered lines and writes a new frame only where needed.
          */
-        function render() {
-            if (isRendering) {
+        function render(options) {
+            if (isRendering || isDisposed) {
                 return;
             }
             isRendering = true;
             try {
-                const lines = buildCoderRunUiFrame({
-                    terminalWidth: getTerminalWidth(),
-                    spinner: SPINNER_FRAMES[spinnerFrame],
-                    pauseState: getPauseState(),
-                    config: state.config,
-                    phase: state.phase,
-                    currentPromptLabel: state.currentPromptLabel,
-                    currentAttempt: state.currentAttempt,
-                    maxAttempts: state.maxAttempts,
-                    statusMessage: state.statusMessage,
-                    detailLines: state.detailLines,
-                    pendingEnterLabel: state.pendingEnterLabel,
-                    agentOutputLines: state.agentOutputLines,
-                    errors: state.errors,
-                    progress: state.getProgress(),
-                });
-                if (previousFrameLineCount > 0) {
-                    process.stdout.write(`\x1b[${previousFrameLineCount}A`);
-                }
-                for (let i = 0; i < lines.length; i++) {
-                    readline.clearLine(process.stdout, 0);
-                    readline.cursorTo(process.stdout, 0);
-                    process.stdout.write(lines[i]);
-                    if (i < lines.length - 1) {
-                        process.stdout.write('\n');
-                    }
+                const lines = buildFrameLines();
+                if (previousFrameLines.length === 0 || previousFrameLines.length !== lines.length) {
+                    renderFullFrame(lines);
                 }
-                if (lines.length < previousFrameLineCount) {
-                    for (let i = lines.length; i < previousFrameLineCount; i++) {
-                        process.stdout.write('\n');
-                        readline.clearLine(process.stdout, 0);
-                        readline.cursorTo(process.stdout, 0);
-                    }
-                    const overshoot = previousFrameLineCount - lines.length;
-                    if (overshoot > 0) {
-                        process.stdout.write(`\x1b[${overshoot}A`);
-                    }
+                else {
+                    renderChangedLines(lines);
                 }
-                previousFrameLineCount = lines.length;
+                previousFrameLines = [...lines];
                 spinnerFrame = (spinnerFrame + 1) % SPINNER_FRAMES.length;
+                if (!(options === null || options === void 0 ? void 0 : options.skipAutoRefresh)) {
+                    scheduleAutoRefresh();
+                }
             }
             finally {
                 isRendering = false;
@@ -49188,12 +49768,8 @@ bash "$1"
                 process.exit(0);
             }
             if (key.name === 'p') {
-                if (getPauseState() === 'RUNNING') {
-                    requestPause();
-                }
-                else {
-                    requestResume();
-                }
+                togglePauseState();
+                scheduleRender();
                 return;
             }
             if ((key.name === 'return' || key.name === 'enter') && pendingEnterResolver) {
@@ -49204,17 +49780,24 @@ bash "$1"
             }
         };
         process.stdin.on('keypress', keypressHandler);
+        process.stdout.on('resize', scheduleRender);
         process.stdout.write('\n');
         render();
-        const interval = setInterval(scheduleRender, UI_REFRESH_INTERVAL_MS);
         state.on('change', scheduleRender);
         /**
          * Tears down the terminal UI and restores console / stdin state.
          */
         function cleanup() {
-            clearInterval(interval);
+            if (isDisposed) {
+                return;
+            }
+            if (autoRefreshTimeout) {
+                clearTimeout(autoRefreshTimeout);
+                autoRefreshTimeout = undefined;
+            }
             state.off('change', scheduleRender);
             process.stdin.off('keypress', keypressHandler);
+            process.stdout.off('resize', scheduleRender);
             if (process.stdin.isTTY) {
                 process.stdin.setRawMode(false);
             }
@@ -49226,8 +49809,9 @@ bash "$1"
             console.warn = originalConsoleWarn;
             console.error = originalConsoleError;
             console.log = originalConsoleLog;
-            render();
+            render({ skipAutoRefresh: true });
             process.stdout.write('\n');
+            isDisposed = true;
         }
         return {
             state,
@@ -49320,6 +49904,23 @@ bash "$1"
         const isRichUiEnabled = !options.dryRun && !options.noUi && Boolean(process.stdout.isTTY);
         const progressDisplay = options.dryRun || options.noUi || isRichUiEnabled ? undefined : new CliProgressDisplay(runStartDate, options.priority);
         const uiHandle = isRichUiEnabled ? renderCoderRunUi(runStartDate) : undefined;
+        const waitForRequestedPause = async () => {
+            await checkPause({
+                silent: isRichUiEnabled,
+                onPaused: () => {
+                    progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.pauseTimer();
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.pauseTimer();
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('paused');
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage('Paused');
+                },
+                onResumed: () => {
+                    progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.resumeTimer();
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.resumeTimer();
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('loading');
+                    uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage('Resuming...');
+                },
+            });
+        };
         // When the Ink UI is active it handles keyboard input itself, so skip the raw stdin listener.
         if (!isRichUiEnabled) {
             listenForPause();
@@ -49436,19 +50037,7 @@ bash "$1"
             let hasShownUpcomingTasks = false;
             let hasWaitedForStart = false;
             while (just(true)) {
-                await checkPause({
-                    silent: isRichUiEnabled,
-                    onPaused: () => {
-                        progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.pauseTimer();
-                        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.pauseTimer();
-                        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('paused');
-                        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage('Paused');
-                    },
-                    onResumed: () => {
-                        progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.resumeTimer();
-                        uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.resumeTimer();
-                    },
-                });
+                await waitForRequestedPause();
                 if (isRichUiEnabled) {
                     uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('loading');
                     uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setStatusMessage('Loading prompts...');
@@ -49516,6 +50105,7 @@ bash "$1"
                 const commitMessage = buildCommitMessage(nextPrompt.file, nextPrompt.section);
                 const codexPrompt = appendCoderContext(buildCodexPrompt(nextPrompt.file, nextPrompt.section), resolvedCoderContext);
                 const scriptPath = buildScriptPath(nextPrompt.file, nextPrompt.section);
+                await waitForRequestedPause();
                 if (isRichUiEnabled) {
                     uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setCurrentPrompt(promptLabel);
                     uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.setPhase('running');
@@ -49574,7 +50164,11 @@ bash "$1"
                             progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.resumeTimer();
                             uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.resumeTimer();
                         }
-                        await commitChanges(commitMessage, { autoPush: options.autoPush });
+                        await commitChanges(commitMessage, {
+                            autoPush: options.autoPush,
+                            // Keep the live runtime log out of default commits because it is deleted after a successful round.
+                            excludePaths: options.preserveLogs ? undefined : [logPath],
+                        });
                         await runPostPromptAutoMigrationIfEnabled(options);
                     }
                     catch (error) {
@@ -53576,9 +54170,10 @@ bash "$1"
      * Build a minimal agent source snapshot for remote agents.
      */
     function buildRemoteAgentSource(profile, meta) {
+        const isMetaImageExplicit = profile.isMetaImageExplicit !== false;
         const metaLines = [
             formatMetaLine('FULLNAME', meta === null || meta === void 0 ? void 0 : meta.fullname),
-            formatMetaLine('IMAGE', meta === null || meta === void 0 ? void 0 : meta.image),
+            formatMetaLine('IMAGE', isMetaImageExplicit ? meta === null || meta === void 0 ? void 0 : meta.image : undefined),
             formatMetaLine('DESCRIPTION', meta === null || meta === void 0 ? void 0 : meta.description),
             formatMetaLine('COLOR', meta === null || meta === void 0 ? void 0 : meta.color),
             formatMetaLine('FONT', meta === null || meta === void 0 ? void 0 : meta.font),
@@ -53677,6 +54272,8 @@ bash "$1"
             remoteAgent._isVoiceCallingEnabled = profile.isVoiceCallingEnabled === true; // [✨✷] Store voice calling status
             remoteAgent._isVoiceTtsSttEnabled = profile.isVoiceTtsSttEnabled !== false;
             remoteAgent.knowledgeSources = profile.knowledgeSources || [];
+            remoteAgent.isMetaImageExplicit = profile.isMetaImageExplicit !== false;
+            remoteAgent.avatarVisualId = profile.avatarVisualId;
             return remoteAgent;
         }
         /**
@@ -53692,6 +54289,8 @@ bash "$1"
             this.toolTitles = {};
             this._isVoiceCallingEnabled = false; // [✨✷] Track voice calling status
             this._isVoiceTtsSttEnabled = true;
+            this.isMetaImageExplicit = true;
+            this.avatarVisualId = undefined;
             this.knowledgeSources = [];
             this.agentUrl = options.agentUrl;
         }