copilot-operator 0.1.1 → 0.1.2

package/dist/src/api/operator.controller.js

@@ -80,6 +80,17 @@ let OperatorController = class OperatorController {
         await this.ops.deletePreset(name);
         return { ok: true };
     }
+    // --- named personas (the import page's second box, saved under a name) -----------------
+    personas() {
+        return this.ops.listPersonas();
+    }
+    savePersona(name, body) {
+        return this.ops.savePersona(name, body?.content ?? '').catch(fail);
+    }
+    async deletePersona(name) {
+        await this.ops.deletePersona(name).catch(fail);
+        return { ok: true };
+    }
     // --- sessions ---------------------------------------------------------------------------
     sessions() {
         return this.ops.listSessions();
@@ -117,6 +128,10 @@ let OperatorController = class OperatorController {
      * A body with `title`, `prompt` or `level2` edits the task on the way: the attempt that
      * already ran keeps the text it ran with, and the next one uses the new text.
      */
+    /** A task that stopped at the runner's limit carries on in its own conversation and branch. */
+    continueTask(id, taskId) {
+        return this.ops.continueTask(id, taskId).catch(fail);
+    }
     rerunTask(id, taskId, body) {
         return this.ops.rerunTask(id, taskId, body ?? {}).catch(fail);
     }
@@ -547,6 +562,27 @@ __decorate([
     __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", Promise)
 ], OperatorController.prototype, "deletePreset", null);
+__decorate([
+    Get('personas'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "personas", null);
+__decorate([
+    Put('personas/:name'),
+    __param(0, Param('name')),
+    __param(1, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "savePersona", null);
+__decorate([
+    Delete('personas/:name'),
+    __param(0, Param('name')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "deletePersona", null);
 __decorate([
     Get('sessions'),
     __metadata("design:type", Function),
@@ -607,6 +643,14 @@ __decorate([
     __metadata("design:paramtypes", [String, String]),
     __metadata("design:returntype", Promise)
 ], OperatorController.prototype, "deleteTask", null);
+__decorate([
+    Post('sessions/:id/tasks/:taskId/continue'),
+    __param(0, Param('id')),
+    __param(1, Param('taskId')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "continueTask", null);
 __decorate([
     Post('sessions/:id/tasks/:taskId/rerun'),
     __param(0, Param('id')),

package/dist/src/api/operator.service.js

@@ -133,6 +133,19 @@ let OperatorService = class OperatorService {
         await this.init();
         await this.store.deletePreset(name);
     }
+    // --- named personas for the import page -----------------------------------------------
+    async listPersonas() {
+        await this.init();
+        return await this.store.listPersonas();
+    }
+    async savePersona(name, content) {
+        await this.init();
+        return await this.store.savePersona(name, content);
+    }
+    async deletePersona(name) {
+        await this.init();
+        await this.store.deletePersona(name);
+    }
     // --- sessions and tasks ---------------------------------------------------------------
     async listSessions() {
         await this.init();
@@ -152,20 +165,17 @@ let OperatorService = class OperatorService {
         if (mirror)
             assertMirrorIsCoherent(mirror);
         const session = await this.store.createSession(name, mirror);
-        // A new session starts on the standing choice, if there is one. It is copied onto the
-        // session rather than read at run time, so changing the default later cannot silently
-        // change what an existing session does.
+        /*
+         * The models are not written onto a new session. A session with no model of its own uses the
+         * one chosen in Settings at the time it runs (see `effectiveModels` in taskRunner.ts), so
+         * choosing a model there reaches every such session, the ones created before it included.
+         * It used to be copied here, which meant a model chosen after an import reached nothing.
+         */
         const cfg = await this.settings.load();
-        const defaultModel = (cfg.copilot.defaultModel ?? '').trim();
-        const defaultReviewModel = (cfg.copilot.defaultReviewModel ?? '').trim();
         const projectDir = (cfg.project?.rootDir ?? '').trim();
-        if (!defaultModel && !defaultReviewModel && !projectDir)
+        if (!projectDir)
             return session;
         return await this.store.updateSession(session.id, (s) => {
-            if (defaultModel)
-                s.model = defaultModel;
-            if (defaultReviewModel)
-                s.review = { enabled: s.review?.enabled !== false, model: defaultReviewModel };
             if (projectDir) {
                 // Both fields, because they answer different questions about the same folder: where the
                 // files are and where the branches go. Neither is switched on by being filled in.
@@ -262,6 +272,20 @@ let OperatorService = class OperatorService {
      * the text it ran with, and only then is the new text applied. Editing in place would leave
      * the old attempt's summary sitting under a question that was never asked.
      */
+    /** "Continue" on a task that stopped at the runner's limit: same chat, same branch, fresh count. */
+    async continueTask(sessionId, taskId) {
+        await this.init();
+        const task = await this.store.continueTask(sessionId, taskId);
+        this.bus.publish({
+            sessionId,
+            taskId,
+            type: 'task-requeued',
+            level: 'info',
+            message: `"${task.title}" is queued to continue where it stopped (attempt ${task.attempt ?? 1})`,
+            data: { attempt: task.attempt, continuing: true },
+        });
+        return task;
+    }
     async rerunTask(sessionId, taskId, patch = {}) {
         await this.init();
         const task = await this.store.rerunTask(sessionId, taskId, patch);
@@ -798,17 +822,27 @@ let OperatorService = class OperatorService {
         const wantedModel = model?.trim();
         const wantedReviewModel = reviewModel?.trim();
         if (wantedModel || wantedReviewModel) {
+            /*
+             * The panel starts on the models chosen in Settings. A session that follows Settings and is
+             * run on exactly that model is left following it, so choosing another model in Settings
+             * later still reaches it; only a different choice, or a session with a model of its own,
+             * is written.
+             */
+            const settingsNow = await this.settings.load();
+            const followModel = (settingsNow.copilot.defaultModel ?? '').trim();
+            const followReview = (settingsNow.copilot.defaultReviewModel ?? '').trim();
             for (const entry of sessions) {
                 if (entry.state !== 'waiting')
                     continue;
                 await this.store.updateSession(entry.sessionId, (s) => {
-                    if (wantedModel)
+                    if (wantedModel && (s.model?.trim() || wantedModel !== followModel))
                         s.model = wantedModel;
                     // Only the model is set here, never whether the review happens: a run panel is about
                     // this run, and silently switching a session's review on or off from it would be a
                     // change to the session that outlives the run.
-                    if (wantedReviewModel)
+                    if (wantedReviewModel && (s.review?.model?.trim() || wantedReviewModel !== followReview)) {
                         s.review = { ...DEFAULT_REVIEW, ...s.review, model: wantedReviewModel };
+                    }
                 });
             }
         }
@@ -1206,7 +1240,8 @@ let OperatorService = class OperatorService {
          * the language asked for; only the shipped example does.
          */
         const persona = (await this.getContext('persona', 'en')).content;
-        const result = await importPlan(this.store, check.plan, (cfg.copilot.defaultModel ?? '').trim(), (cfg.copilot.defaultReviewModel ?? '').trim(), persona);
+        // No default models passed: a session the plan gives no model follows Settings at run time.
+        const result = await importPlan(this.store, check.plan, '', '', persona);
         return {
             ok: true,
             result: { ...result, warnings: [...check.warnings, ...result.warnings] },

package/dist/src/config/schema.js

@@ -306,8 +306,14 @@ export const RunConfigSchema = z.object({
         .prefault({}),
     limits: z
         .object({
-        maxIterations: z.number().int().positive().default(30),
-        maxRunMinutes: z.number().int().positive().default(120),
+        /*
+         * Per task, and a guard against a task that loops, not against message volume: that is
+         * `pacing.maxMessagesPerHour`, which waits rather than stops. Raised from 30 and 120 on
+         * 2026-09-28 at the operator's decision — Copilot keeps a long conversation in view, and a
+         * task cut off at 30 had to start over. Both are set in Settings → Execution.
+         */
+        maxIterations: z.number().int().positive().default(60),
+        maxRunMinutes: z.number().int().positive().default(240),
         maxFormatRetries: z.number().int().nonnegative().default(2),
         maxMessageChars: z.number().int().positive().default(100_000),
         /**

package/dist/src/orchestrator/taskRunner.js

@@ -14,7 +14,7 @@ import { createHash } from 'node:crypto';
 import { readFile, mkdir, writeFile, appendFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { CopilotTransport } from '../transport/copilotTransport.js';
-import { buildChatName, savePointer } from '../transport/chatSession.js';
+import { buildChatName, chatCode, savePointer } from '../transport/chatSession.js';
 import { parseReply, formatErrorMessage, findLikelyDamage, damageGuidance } from '../protocol/parser.js';
 import { resolveDeviations, describeDeviations, mergeDisputes, describeDisputes } from '../protocol/replySchema.js';
 import { buildCoveringMessage, assertSendable } from '../protocol/reporter.js';
@@ -263,10 +263,22 @@ export async function openSessionTransport(cfg, session, bus, runsDir) {
  * set to, and the session records that, so the register shows which model did the work rather
  * than which one was asked for.
  */
-async function applySessionModel(transport, session, bus) {
-    if (!session.model?.trim())
+/**
+ * The models a session runs on: its own, or else the ones chosen in Settings at this moment.
+ * A session gets a model of its own from the plan or from its own picker; one that has none
+ * follows Settings, so a model chosen there after the session was made still reaches it.
+ */
+export function effectiveModels(session, cfg) {
+    return {
+        model: (session.model ?? '').trim() || (cfg.copilot.defaultModel ?? '').trim(),
+        reviewModel: (session.review?.model ?? '').trim() || (cfg.copilot.defaultReviewModel ?? '').trim(),
+    };
+}
+async function applySessionModel(transport, session, bus, cfg) {
+    const wanted = effectiveModels(session, cfg).model;
+    if (!wanted)
         return undefined;
-    const result = await transport.selectModel(session.model.trim()).catch((e) => ({
+    const result = await transport.selectModel(wanted).catch((e) => ({
         ok: false,
         current: null,
         reason: e.message,
@@ -276,9 +288,9 @@ async function applySessionModel(transport, session, bus) {
         type: result.ok ? 'model-selected' : 'model-not-selected',
         level: result.ok ? 'info' : 'warn',
         message: result.ok
-            ? `model: ${result.current ?? session.model}`
-            : `could not switch to "${session.model}": ${result.reason ?? 'unknown reason'}. Continuing on ${result.current ?? 'the chat default'}.`,
-        data: { asked: session.model, current: result.current, ok: result.ok },
+            ? `model: ${result.current ?? wanted}${session.model?.trim() ? '' : ' (from Settings)'}`
+            : `could not switch to "${wanted}": ${result.reason ?? 'unknown reason'}. Continuing on ${result.current ?? 'the chat default'}.`,
+        data: { asked: wanted, fromSettings: !session.model?.trim(), current: result.current, ok: result.ok },
     });
     return result.current ?? undefined;
 }
@@ -587,6 +599,7 @@ export async function runTask(transport, session, task, deps) {
             taskTitle: task.title,
             taskNumber,
             contractAlreadySent: session.contractSent,
+            continuing: task.continuing,
             workDirNote: workingDirNote(work),
             vcsNote: prepared.note,
             readOnlyNote: task.readOnly ? READ_ONLY_NOTE : undefined,
@@ -613,7 +626,7 @@ export async function runTask(transport, session, task, deps) {
             if (!session.chat) {
                 const chatId = await transport.currentChatId();
                 if (chatId) {
-                    const name = buildChatName(session.id.slice(0, 15), session.name);
+                    const name = buildChatName(chatCode(session.id), session.name);
                     await transport.nameChat(chatId, name).catch(() => false);
                     const chat = {
                         chatId,
@@ -810,7 +823,7 @@ export async function runTask(transport, session, task, deps) {
                 return 'accept';
             }
             reviewRounds += 1;
-            const model = (session.review?.model ?? '').trim();
+            const model = effectiveModels(session, cfg).reviewModel;
             const repoDir = session.vcs?.enabled ? (session.vcs.repoDir ?? '').trim() : '';
             /*
              * What changed, read from git rather than from anybody's account of it.
@@ -1462,8 +1475,8 @@ export async function runSession(sessionId, deps) {
         const chat = transport;
         // The picker belongs to the conversation, so the session's choice is applied once, here,
         // before the first task goes out. What the chat ended up on is recorded either way.
-        const modelInUse = await applySessionModel(chat, session, bus);
-        if (session.model?.trim()) {
+        const modelInUse = await applySessionModel(chat, session, bus, cfg);
+        if (effectiveModels(session, cfg).model) {
             await store.updateSession(sessionId, (s) => {
                 s.modelInUse = modelInUse;
             });
@@ -1527,8 +1540,8 @@ export async function runSession(sessionId, deps) {
                  * it was the model the session asked for. The review has always done this for its own
                  * fresh conversations a few hundred lines up; this path simply never did.
                  */
-                const freshModel = await applySessionModel(chat, session, bus);
-                if (session.model?.trim()) {
+                const freshModel = await applySessionModel(chat, session, bus, cfg);
+                if (effectiveModels(session, cfg).model) {
                     session = await store.updateSession(sessionId, (s) => {
                         s.modelInUse = freshModel;
                     });

package/dist/src/plan/importPlan.js

@@ -139,8 +139,9 @@ function unavailableShellWarnings(plan) {
 /**
  * Creates everything the plan describes.
  *
- * `defaultModel` is what a session starts on when the plan does not name one, which keeps an
- * imported session behaving like one made by hand in the UI.
+ * `defaultModel` is written onto a session the plan names no model for. The service passes
+ * nothing: such a session follows the model chosen in Settings at the time it runs, like one made
+ * by hand in the UI. Kept as a parameter for a caller that wants the old, copied behaviour.
  */
 export async function importPlan(store, plan, defaultModel = '', defaultReviewModel = '', 
 /** The operator's persona at the moment of import, written into every task's level 2. */

package/dist/src/plan/systemGuide.js

@@ -225,6 +225,38 @@ export const SYSTEM_GUIDE = [
                 en: 'How the tasks are carried out: the agent\'s persona',
                 bg: 'Как се изпълняват задачите: персоната на агента',
                 controls: [
+                    {
+                        key: 'plan.personaSaved',
+                        kind: 'select',
+                        en: 'Saved personas',
+                        bg: 'Запазени персони',
+                        doesEn: 'Chooses a saved persona and puts it in the box below, which is saved at once; the choice shows which saved persona the box matches.',
+                        doesBg: 'Избира запазена персона и я поставя в полето отдолу, което се запазва веднага; изборът показва на коя запазена персона отговаря полето.',
+                    },
+                    {
+                        key: 'plan.personaNamePlaceholder',
+                        kind: 'field',
+                        en: 'a name for the persona in the box, e.g. playwright-tests',
+                        bg: 'име за персоната в полето, напр. playwright-tests',
+                        doesEn: 'The name to keep the persona in the box under.',
+                        doesBg: 'Името, под което да се запази персоната от полето.',
+                    },
+                    {
+                        key: 'plan.personaSaveAs',
+                        kind: 'button',
+                        en: 'Save under this name',
+                        bg: 'Запази под това име',
+                        doesEn: 'Keeps a copy of the persona in the box under that name, replacing one of the same name after asking.',
+                        doesBg: 'Запазва копие на персоната от полето под това име, като пита, преди да замени персона със същото име.',
+                    },
+                    {
+                        key: 'plan.personaDelete',
+                        kind: 'button',
+                        en: 'Delete the chosen one',
+                        bg: 'Изтрий избраната',
+                        doesEn: 'Deletes the saved persona the box matches; the box itself is not changed.',
+                        doesBg: 'Изтрива запазената персона, на която отговаря полето; самото поле не се променя.',
+                    },
                     {
                         key: 'plan.ctxClear',
                         kind: 'button',
@@ -913,6 +945,14 @@ export const SYSTEM_GUIDE = [
                         doesEn: "Opens the form for that task's title, level 2, task text, git names and checks.",
                         doesBg: 'Отваря формата за заглавието, ниво 2, текста, git имената и проверките на задачата.',
                     },
+                    {
+                        key: 'task.continue',
+                        kind: 'button',
+                        en: 'Continue in the same chat',
+                        bg: 'Продължи в същия чат',
+                        doesEn: 'Only on a task that stopped as limit reached: queues it to carry on in the same chat and on the same branch, with a fresh count of messages.',
+                        doesBg: 'Само на задача, спряла като достигнат лимит: връща я в опашката да продължи в същия чат и клон, с нов брояч на съобщенията.',
+                    },
                     {
                         key: 'task.rerun',
                         kind: 'button',
@@ -1628,6 +1668,22 @@ export const SYSTEM_GUIDE = [
                 en: 'Execution',
                 bg: 'Изпълнение',
                 controls: [
+                    {
+                        key: 'exec.maxIterations',
+                        kind: 'field',
+                        en: 'Most messages to the chat in one task',
+                        bg: 'Най-много съобщения към чата в една задача',
+                        doesEn: 'How many rounds one task may take (default 60) before it stops as limit reached; saved as you type.',
+                        doesBg: 'Колко кръга може да отнеме една задача (по подразбиране 60), преди да спре като достигнат лимит; запазва се, докато пишете.',
+                    },
+                    {
+                        key: 'exec.maxRunMinutes',
+                        kind: 'field',
+                        en: 'Longest a task may run',
+                        bg: 'Най-дълго време за една задача',
+                        doesEn: 'How many minutes one task may run (default 240) before it stops as limit reached; saved as you type.',
+                        doesBg: 'Колко минути може да върви една задача (по подразбиране 240), преди да спре като достигнат лимит; запазва се, докато пишете.',
+                    },
                     {
                         key: 'exec.retryBlocked',
                         kind: 'field',

package/dist/src/session/compose.js

@@ -52,8 +52,27 @@ function level2Block(level2) {
  */
 export function composeOpening(input) {
     const taskBlock = `${TASK_HEADER} ${input.taskNumber}: ${input.taskTitle.trim() || 'untitled'}\n\n${input.prompt.trim()}`;
+    /*
+     * Carrying on in the same conversation: the assignment is already in it, so it is not sent
+     * again — sending it would read as a new task and start the work over. Only when the
+     * conversation was lost does the task go out in full, with a line saying it is a continuation.
+     */
+    if (input.continuing && input.contractAlreadySent) {
+        const why = input.continuing.stoppedBecause ? ` (${input.continuing.stoppedBecause})` : '';
+        const message = `Continue task ${input.taskNumber}: ${input.taskTitle.trim() || 'untitled'}, in this same conversation. ` +
+            `It stopped because the runner's limit was reached${why} — not because anything failed. ` +
+            `The files are as you left them. Do not start over and do not repeat work that is done: start from ` +
+            `your plan, say in \`notes\` which stages are done and which one you are on, and carry on. ` +
+            `The assignment is the one you were given above; it has not changed. Step numbering restarts at 1.\n\n` +
+            `${runnerBlock(input)}`.trimEnd();
+        return { messages: [message], firstMessage: message };
+    }
+    const continuationLine = input.continuing
+        ? `\n\nThis continues an earlier attempt at this task that stopped at the runner's limit. The files are as ` +
+            `that attempt left them: look at what is already done before changing anything, and carry on from there.`
+        : '';
     if (!input.contractAlreadySent) {
-        const taskMessage = `${runnerBlock(input)}${level2Block(input.level2)}\n\n${taskBlock}`;
+        const taskMessage = `${runnerBlock(input)}${level2Block(input.level2)}\n\n${taskBlock}${continuationLine}`;
         return {
             messages: [input.level1.trim(), taskMessage],
             firstMessage: `${input.level1.trim()}\n\n---\n\n${taskMessage}`,
@@ -62,6 +81,6 @@ export function composeOpening(input) {
     const reminder = `New task in this same conversation. The level 1 contract you received at the start of ` +
         `this conversation still applies unchanged: same format, same rules, same stop word, ` +
         `and a full "summary" when you finish. Step numbering restarts at 1.`;
-    const taskMessage = `${reminder}\n\n${runnerBlock(input)}${level2Block(input.level2)}\n\n${taskBlock}`;
+    const taskMessage = `${reminder}\n\n${runnerBlock(input)}${level2Block(input.level2)}\n\n${taskBlock}${continuationLine}`;
     return { messages: [taskMessage], firstMessage: taskMessage };
 }

package/dist/src/session/store.js

@@ -47,6 +47,8 @@ export class SessionStore {
     dir;
     sessionsDir;
     presetsDir;
+    /** Named personas the operator keeps for the import page, one file each. */
+    personasDir;
     level1Path;
     modelsPath;
     constructor(dataDir, defaultLevel1Path) {
@@ -54,6 +56,7 @@ export class SessionStore {
         this.dir = resolve(dataDir);
         this.sessionsDir = join(this.dir, 'sessions');
         this.presetsDir = join(this.dir, 'level2');
+        this.personasDir = join(this.dir, 'personas');
         this.level1Path = join(this.dir, 'level1.md');
         this.modelsPath = join(this.dir, 'models.json');
     }
@@ -134,6 +137,36 @@ export class SessionStore {
     async deletePreset(name) {
         await rm(join(this.presetsDir, `${safePresetName(name)}.md`), { force: true });
     }
+    // --- named personas -------------------------------------------------------------------
+    //
+    // "How the tasks are carried out" is one box on the import page, and the persona in it depends
+    // on the kind of work: a Playwright suite wants a different agent from an API service. These
+    // are saved copies of that box under a name, so switching is one choice instead of pasting a
+    // JSON back in. The box itself (`context-persona.md`) stays the one that is in force.
+    async listPersonas() {
+        const names = (await readdir(this.personasDir).catch(() => []))
+            .filter((n) => n.endsWith('.md'))
+            .sort((a, b) => a.localeCompare(b));
+        const out = [];
+        for (const n of names) {
+            const path = join(this.personasDir, n);
+            const content = await readFile(path, 'utf8');
+            const { mtime } = await import('node:fs').then((fs) => fs.statSync(path));
+            out.push({ name: n.slice(0, -3), content, updatedAt: mtime.toISOString() });
+        }
+        return out;
+    }
+    async savePersona(name, content) {
+        const safe = name.replace(/[^\p{L}\p{N}._ -]/gu, '').trim();
+        if (!safe)
+            throw new Error('The persona name is empty after removing unsafe characters.');
+        await mkdir(this.personasDir, { recursive: true });
+        await this.atomicWrite(join(this.personasDir, `${safePresetName(safe)}.md`), content);
+        return { name: safe, content, updatedAt: new Date().toISOString() };
+    }
+    async deletePersona(name) {
+        await rm(join(this.personasDir, `${safePresetName(name)}.md`), { force: true });
+    }
     // --- sessions -------------------------------------------------------------------------
     /**
      * Every session, newest first — by when it was made, not by what it is called.
@@ -258,7 +291,23 @@ export class SessionStore {
      * the retry destroys exactly the thing that made the retry interesting. The run folder of
      * the old attempt is untouched too, because the next attempt gets a folder of its own.
      */
-    async rerunTask(sessionId, taskId, patch = {}) {
+    /**
+     * Queues a task that stopped at the runner's limit to carry on where it stopped: the same
+     * conversation, the same branch, a fresh count of messages. The attempt that stopped is kept on
+     * the record like any other.
+     */
+    async continueTask(sessionId, taskId) {
+        const current = (await this.getSession(sessionId))?.tasks.find((x) => x.id === taskId);
+        if (!current)
+            throw new Error(`Task ${taskId} does not exist in session ${sessionId}.`);
+        if (current.status !== 'limit-reached') {
+            throw new Error('Only a task that stopped at the runner\'s limit can be continued; run this one again instead.');
+        }
+        return await this.rerunTask(sessionId, taskId, {}, { fromAttempt: current.attempt ?? 1, stoppedBecause: current.reason });
+    }
+    async rerunTask(sessionId, taskId, patch = {}, 
+    /** Present when the new attempt carries on from the last one (see `continueTask`). */
+    continuing) {
         let result;
         await this.updateSession(sessionId, (s) => {
             const t = s.tasks.find((x) => x.id === taskId);
@@ -304,6 +353,7 @@ export class SessionStore {
             t.attempt = (t.attempt ?? 1) + 1;
             t.status = 'queued';
             t.iterations = 0;
+            t.continuing = continuing;
             // Cleared so the next run starts from nothing and gets its own run folder.
             t.runId = undefined;
             t.runGroup = undefined;

package/dist/src/transport/chatSession.js

@@ -19,16 +19,28 @@ import { dirname } from 'node:path';
 /** The UI rejects anything longer. Verified live: "Your Copilot chat name can't be longer than 50 characters". */
 export const MAX_CHAT_NAME = 50;
 export const CHAT_URL_RE = /\/chat\/conversation\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i;
+/**
+ * The short code a session's chats are named with: the random tail of its id
+ * (`20260928-073140-ujdt` gives `ujdt`), which the session page's address shows too.
+ *
+ * It replaced the date and time (`20260928-073140`), which took 15 of the 50 characters Copilot
+ * allows and left the session's own name 31; with the code it keeps 42 (asked for 2026-09-28).
+ * An id without such a tail gives its last six letters and digits.
+ */
+export function chatCode(sessionId) {
+    const tail = /-([a-z0-9]{3,8})$/i.exec(sessionId)?.[1];
+    return (tail ?? sessionId.replace(/[^a-z0-9]/gi, '').slice(-6)).toLowerCase();
+}
 /**
  * Builds the chat name. Shape:
  *
- *   op/<runId>/<label>
+ *   op/<code>/<label>
  *
  * The `op/` prefix makes every bot chat greppable in the sidebar and separates them from
- * the user's own chats. The run id ties the chat to the transcript on disk. The label is
- * whatever the run config calls the task.
+ * the user's own chats. The code ties the chat to its session (see `chatCode`). The label is
+ * the session's name.
  *
- * The whole thing is squeezed into 50 characters: the prefix and run id are kept intact
+ * The whole thing is squeezed into 50 characters: the prefix and the code are kept intact
  * because they are what makes the chat findable, and the label absorbs the truncation.
  */
 export function buildChatName(runId, label) {

package/dist/src/vcs/taskVcs.js

@@ -57,6 +57,11 @@ export async function prepareForTask(session, task, bus, saveSession) {
     const wanted = plannedBranch
         ? plannedBranchName(plannedBranch, prefix, attempt)
         : branchNameFrom([session.name, task.title, attempt > 1 ? `a${attempt}` : undefined], prefix);
+    // A continuation carries on where the previous attempt stopped, on that attempt's own branch:
+    // its work is what is being continued. See `continueTask` in the store.
+    const previousBranch = task.continuing ? task.attempts?.at(-1)?.vcs?.branch : undefined;
+    if (previousBranch)
+        return await switchTo(session, task, dir, previousBranch, base, bus, { reuseExisting: true });
     // A re-run starts from where that task started the first time, not from where the previous
     // attempt ended. That is the whole point of recording the base commit.
     const from = firstAttemptBase(task) ?? base;