copilot-operator 0.1.1 → 0.1.3

package/README.md

@@ -82,7 +82,11 @@ file run. What `Start-Process` is asked to start is judged like any other progra
 `Invoke-WebRequest`, `Invoke-RestMethod`, `curl`, `wget`, `Start-BitsTransfer`, the .NET web
 clients, `ftp`/`scp`, a package named by URL or git address, `npx` of a tool not installed in the
 project, `docker pull` — is neither refused nor run: it waits on the approval screen, in every
-mode, unattended included, and "run the rest without asking" does not answer it. A check that
+mode, unattended included, and "run the rest without asking" does not answer it. That is the
+default, and the one stop an unattended run still makes; `execution.networkFetch` (Settings →
+Execution) may instead **refuse** it back to the chat with the reason, so the run never waits, or
+**run** it unread on a machine where that is acceptable. The choice applies only to unattended
+runs, and each task's policy manifest records which was in force. A check that
 fetches is refused, since a check runs with nobody asked. Requests to this machine (`localhost`,
 `127.0.0.1`) and the project's own package managers are not held. `npm install` runs with
 `ignore-scripts`: a package's install script is code fetched and executed unread, and it does not

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);
@@ -594,6 +618,8 @@ let OperatorService = class OperatorService {
             allowedPrograms: cfg.execution.allowedPrograms,
             isolation: cfg.execution.isolation,
             lockedToConfirm: cfg.policyLock?.maxMode === 'confirm',
+            // Read once per run like the rest of the policy: a change in Settings applies from the next start.
+            networkFetch: cfg.execution.networkFetch,
         };
         /*
          * An unattended run that cannot legally execute anything is stopped here, where the operator
@@ -798,17 +824,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 +1242,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/cli.js

@@ -484,6 +484,7 @@ program
         allowedPrograms: cfg.execution.allowedPrograms,
         isolation: cfg.execution.isolation,
         lockedToConfirm: cfg.policyLock?.maxMode === 'confirm',
+        networkFetch: cfg.execution.networkFetch,
     };
     const authorizer = cfg.execution.mode === 'unattended'
         ? unattendedAuthorizer(policy)

package/dist/src/config/schema.js

@@ -117,7 +117,32 @@ export const RunConfigSchema = z.object({
     task: TextOrFile.optional(),
     execution: z
         .object({
+        /*
+         * For the terminal, the mode `cop run` uses without `--unattended`. For the API it is the
+         * operator's standing choice from Settings: `unattended` means an unattended start is not
+         * questioned again with "are you sure" — they said so once, on the Settings page, and asking
+         * at every press is exactly the interruption they switched off. Every start still names its
+         * own mode; this never turns a step-by-step press into an unattended run.
+         */
         mode: z.enum(['confirm', 'unattended']).default('confirm'),
+        /**
+         * What an unattended run does with a step that fetches from the network. See `network.ts`.
+         *
+         *   ask     it waits on the approval screen for the operator, as it did before this setting
+         *           existed — the one question an unattended run still asks.
+         *   refuse  it is not run, and the chat is told why at once and what to do instead, so the
+         *           run never stops to wait for anybody. The terminal's unattended form has always
+         *           done this, because it has nobody to ask.
+         *   run     it runs like every other step, with nobody having read it.
+         *
+         * `ask` is the default because the hold exists for a reason — a security team found
+         * model-written steps staging and running code on a work laptop — and a run that can fetch
+         * and then execute what arrived, unread, is the thing it was built to prevent. `run` is the
+         * operator's to choose on a machine where that is acceptable, and it is recorded in every
+         * task's policy manifest as exactly that. A step-by-step run is unaffected: every step
+         * there, a fetch included, is put in front of a person anyway.
+         */
+        networkFetch: z.enum(['ask', 'refuse', 'run']).default('ask'),
         /**
          * The shell a step or a check runs in when it names none of its own.
          *
@@ -306,8 +331,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/exec/authorizer.js

@@ -6,11 +6,14 @@ import { stdin, stdout } from 'node:process';
 /**
  * Runs the static rules, then, unless unattended, asks the human through `ask`.
  *
- * A step that fetches from the network is the exception to "unless unattended": it is asked about
- * in every mode, with `held` saying why, because the runs nobody is watching are exactly the ones
- * in which a download followed by a second step that runs it would otherwise go unseen. `cfg` is
- * read on every call, not captured, so a run switched to unattended half-way is judged as one from
- * its next step on.
+ * A step that fetches from the network is the exception to "unless unattended": by default it is
+ * asked about in every mode, with `held` saying why, because the runs nobody is watching are
+ * exactly the ones in which a download followed by a second step that runs it would otherwise go
+ * unseen. The operator may choose otherwise for unattended runs (`cfg.networkFetch`): `refuse`
+ * answers the chat at once instead of waiting for anybody, `run` treats the fetch like any other
+ * step. Only for unattended runs — a watched run shows the fetch like every other step, and the
+ * person reading it is the whole point of watching. `cfg` is read on every call, not captured, so
+ * a run switched to unattended half-way is judged as one from its next step on.
  */
 export function makeAuthorizer(cfg, ask) {
     return {
@@ -20,8 +23,13 @@ export function makeAuthorizer(cfg, ask) {
                 return blocked;
             const cwd = ctx.confinement?.cwd;
             const network = networkFetchReason(step.cmd, cwd) ?? (cwd ? scriptNetworkReason(step.cmd, cwd) : null);
-            if (network)
+            if (network) {
+                if (cfg.mode === 'unattended' && cfg.networkFetch === 'refuse')
+                    return { action: 'skip', reason: networkFetchRefusal(network) };
+                if (cfg.mode === 'unattended' && cfg.networkFetch === 'run')
+                    return { action: 'run' };
                 return await ask(step, ctx, { network });
+            }
             if (cfg.mode === 'unattended')
                 return { action: 'run' };
             return await ask(step, ctx);
@@ -53,8 +61,10 @@ export function terminalAuthorizer(cfg, print) {
  * Everything runs after the static rules. Only for runs the user explicitly marked so.
  *
  * A step held for a person (a network fetch) is refused here, with the reason, because this form
- * has nobody to ask. The web UI does not use it: its unattended runs keep the approval screen for
- * exactly those steps.
+ * has nobody to ask — `ask` and `refuse` come to the same thing at a terminal nobody is at. Only
+ * `networkFetch: run` lets one through, and that is decided in `makeAuthorizer` before this is
+ * reached. The web UI does not use it: its unattended runs keep the approval screen for exactly
+ * those steps.
  */
 export function unattendedAuthorizer(cfg) {
     return makeAuthorizer({ ...cfg, mode: 'unattended' }, async (_step, _ctx, held) => held ? { action: 'skip', reason: networkFetchRefusal(held.network) } : { action: 'run' });

package/dist/src/exec/policyManifest.js

@@ -31,7 +31,21 @@ export function digestOf(values) {
     const canonical = JSON.stringify([...values].map((v) => v.trim()).filter(Boolean).sort());
     return createHash('sha256').update(canonical).digest('hex').slice(0, 12);
 }
-export const NETWORK_FETCH = "a command that fetches from the network (Invoke-WebRequest, Invoke-RestMethod, curl, wget, Start-BitsTransfer, .NET web clients, ftp/scp) is held for the operator in every mode; with nobody to ask it is refused. Requests to localhost and the project's package managers are not held";
+const FETCHES = 'a command that fetches from the network (Invoke-WebRequest, Invoke-RestMethod, curl, wget, Start-BitsTransfer, .NET web clients, ftp/scp)';
+const NOT_HELD = "Requests to localhost and the project's package managers are not held";
+/**
+ * The manifest's sentence about downloads, for this mode and the operator's choice. A step-by-step
+ * run shows every step to a person, so the choice changes nothing there and is not mentioned.
+ */
+export function networkFetchStatement(mode, choice = 'ask') {
+    if (mode === 'confirm')
+        return `${FETCHES} is shown to the operator with a note that it downloads, like every step of this run. ${NOT_HELD}`;
+    if (choice === 'refuse')
+        return `${FETCHES} is refused back to the chat without running (execution.networkFetch: refuse). ${NOT_HELD}`;
+    if (choice === 'run')
+        return `${FETCHES} RUNS WITHOUT ANYONE READING IT — the operator chose this (execution.networkFetch: run). Only the deny list and the built-in refusals applied`;
+    return `${FETCHES} is held for the operator even in this unattended run (execution.networkFetch: ask); with nobody to ask it is refused. ${NOT_HELD}`;
+}
 export function collectPolicyManifest(input, env = process.env) {
     const names = DANGEROUS_TECHNIQUES.map((t) => t.name);
     return {
@@ -46,7 +60,7 @@ export function collectPolicyManifest(input, env = process.env) {
             programs: [...input.allowedPrograms],
         },
         chatFiles: 'the chat cannot supply a file: this runner has no file step and executes nothing it did not receive as a command',
-        networkFetch: NETWORK_FETCH,
+        networkFetch: networkFetchStatement(input.mode, input.networkFetch),
         denyPatterns: { count: input.denyPatterns.length, digest: digestOf(input.denyPatterns) },
         builtIn: { count: names.length, digest: digestOf(names), names },
         lock: input.lock ?? { applied: false, changes: [] },

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;
 }
@@ -513,6 +525,7 @@ export async function runTask(transport, session, task, deps) {
         isolation,
         confinedTo: confinement.roots,
         mode: deps.currentMode?.() ?? cfg.execution.mode,
+        networkFetch: cfg.execution.networkFetch,
         allowedPrograms: cfg.execution.allowedPrograms,
         denyPatterns: cfg.execution.denyPatterns,
         cwd: work.cwd,
@@ -587,6 +600,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 +627,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 +824,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 +1476,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 +1541,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',
@@ -549,16 +581,16 @@ export const SYSTEM_GUIDE = [
                         kind: 'button',
                         en: 'Run this and the rest without asking',
                         bg: 'Изпълни без да питаш повече',
-                        doesEn: 'Runs it and stops asking about every command after it until this run ends, except a command that downloads from the internet. Not offered on such a command.',
-                        doesBg: 'Изпълнява я и спира да пита за следващите команди до края на това пускане, освен за команда, която тегли от интернет. Не се предлага на такава команда.',
+                        doesEn: 'Runs it and stops asking about every command after it until this run ends, except a command that downloads from the internet, which follows the choice in Settings → Execution. Not offered on such a command.',
+                        doesBg: 'Изпълнява я и спира да пита за следващите команди до края на това пускане, освен за команда, която тегли от интернет — за нея важи изборът в Настройки → Изпълнение. Не се предлага на такава команда.',
                     },
                     {
                         key: 'approval.network',
                         kind: 'note',
-                        en: 'This command downloads from the internet. The bot never does that on its own, even in a run that does not ask, because a later step could run what arrived. Run it only if you know what it fetches and why.',
-                        bg: 'Тази команда тегли от интернет. Ботът никога не го прави сам, дори при пускане без питане, защото следваща стъпка може да пусне изтегленото. Изпълнете я само ако знаете какво тегли и защо.',
-                        doesEn: 'Shown on a step that fetches from the network. Such a step waits here in every run, including one that does not ask; requests to localhost and package installs through npm or dotnet do not.',
-                        doesBg: 'Показва се на стъпка, която тегли от мрежата. Такава стъпка чака тук при всяко пускане, включително без питане; заявки към localhost и пакети през npm или dotnet не чакат.',
+                        en: 'This command downloads from the internet. A run that does not ask still stops for this one (unless Settings → Execution says otherwise), because a later step could run what arrived. Run it only if you know what it fetches and why.',
+                        bg: 'Тази команда тегли от интернет. Пускане без питане също спира за нея (освен ако Настройки → Изпълнение не казва друго), защото следваща стъпка може да пусне изтегленото. Изпълнете я само ако знаете какво тегли и защо.',
+                        doesEn: 'Shown on a step that fetches from the network. Such a step waits here in every run, including one that does not ask, unless Settings → Execution has chosen to refuse or run such commands in a run without supervision; requests to localhost and package installs through npm or dotnet never wait.',
+                        doesBg: 'Показва се на стъпка, която тегли от мрежата. Такава стъпка чака тук при всяко пускане, включително без питане, освен ако в Настройки → Изпълнение не е избрано такива команди да се отказват или изпълняват при пускане без надзор; заявки към localhost и пакети през npm или dotnet никога не чакат.',
                     },
                     {
                         key: 'approval.skip',
@@ -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',
@@ -1644,6 +1700,22 @@ export const SYSTEM_GUIDE = [
                         doesEn: "The operator's statement about what contains this runner: this account, a separate low-privilege Windows account, Windows Sandbox, or a VM. It gates unattended runs — while it says this account, a run with nobody watching is refused, unless the operator chose \"this account — I accept unattended runs without isolation\", which allows it on their responsibility — and it is recorded with every run beside the account the process actually held.",
                         doesBg: 'Твърдението на оператора какво огражда този runner: този акаунт, отделен Windows акаунт с малки права, Windows Sandbox или виртуална машина. То управлява пусканията без надзор — докато казва „този акаунт“, пускане без човек се отказва, освен ако операторът не е избрал „в този акаунт — приемам пускане без надзор без изолация“, което го позволява на негова отговорност — и се записва с всяко пускане до акаунта, който процесът наистина е държал.',
                     },
+                    {
+                        key: 'exec.startMode',
+                        kind: 'select',
+                        en: 'Starting a run without supervision',
+                        bg: 'Пускане без надзор',
+                        doesEn: 'Whether the run buttons that work through the queue on their own ask "are you sure" first ("Ask \"are you sure\" every time", the default) or simply start ("Start it without asking"). Step by step stays available beside them either way.',
+                        doesBg: 'Дали бутоните, които минават през опашката сами, питат първо „сигурен ли си“ („Питай „сигурен ли си“ всеки път“, по подразбиране) или просто тръгват („Пускай, без да питаш“). „Стъпка по стъпка“ остава до тях и в двата случая.',
+                    },
+                    {
+                        key: 'exec.networkFetch',
+                        kind: 'select',
+                        en: 'A command that downloads, in a run without supervision',
+                        bg: 'Команда, която тегли от интернет, при пускане без надзор',
+                        doesEn: 'What a run without supervision does with Invoke-WebRequest, curl, wget and the like: wait for the operator on the approval screen (the default), refuse it and tell the chat why so the run never waits, or run it without anyone reading it. Recorded in every task. A step-by-step run shows every command whatever is chosen.',
+                        doesBg: 'Какво прави пускане без надзор с Invoke-WebRequest, curl, wget и подобни: чака оператора на екрана за одобрение (по подразбиране), отказва я и казва на чата защо, така че пускането никога не чака, или я изпълнява, без никой да я е прочел. Записва се във всяка задача. При „стъпка по стъпка“ всяка команда се показва, каквото и да е избрано.',
+                    },
                 ],
             },
         ],

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 };
 }