deel-local-cli 1.8.0 → 1.10.0

package/src/agent/session.js

@@ -1,5 +1,5 @@
 // 대화 상태와 컨텍스트 셈. /context 가 보여주는 숫자가 여기서 나온다.
-import { readFileSync, existsSync } from 'node:fs';
+import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { 그림장수, 글만, 그림한장토큰 } from '../backend/vision.js';
 import { get as workMode, 말 as 모드말, DEFAULT as WORK_DEFAULT } from './modes.js';
@@ -9,6 +9,7 @@ import { 매김, 급말, 값 as 급값, 지켜본것 } from './grade.js';
 import { 지문 } from './project.js';
 import { 프롬프트토막 as 기억토막 } from './memory.js';
 import { 못박기 } from './pins.js';
+import { 파일기억 } from './filemem.js';
 import { 언어, 지시말, 말 as 옮긴말 } from '../i18n/index.js';
 import { 셸안내 } from '../tools/shell.js';
 
@@ -231,6 +232,27 @@ export class Session {
      */
     this.못박은것 = new 못박기();
     this.filesRead = new Map();   // 경로 → 추정 토큰
+    /*
+     * 읽은 파일을 들고 있다가 **바뀐 만큼만** 다시 싣는다 (agent/filemem.js).
+     *
+     * filesRead 와 둘로 나눠 둔 이유: 저쪽은 `/context` 가 「몇 개 읽었나」 를
+     * 세는 자리라 값이 토큰 수뿐이다. 여기는 글 자체를 들고 있어야 한다.
+     * 한 맵에 두 가지를 담으면 화면 셈이 글자까지 들고 다니게 된다.
+     */
+    this.파일기억 = new 파일기억();
+    /*
+     * 접거나 줄여도 잃으면 안 되는 두 가지 (아래 못박을것).
+     *
+     *   이번요청 — 이번 턴에 사람이 시킨 말 원문. loop.js 가 턴마다 채운다.
+     *   할일     — 마지막 TodoWrite 목록. loop.js 가 그 결과에서 채운다.
+     *
+     * 요약은 요약이라 「네 가지를 고쳐 달라고 했다」로 뭉개지고, 할 일 목록은
+     * 도구 결과 자리에만 살아서 접히면 통째로 사라진다. 둘 다 접는 자리에서
+     * 다시 박으려면 세션이 들고 있어야 한다 — ctx 에만 두면 우리 코드만 보고
+     * 모델은 못 본다.
+     */
+    this.이번요청 = '';
+    this.할일 = [];
     this.changes = new Map();     // 경로 → {added, removed, times}. /diff 가 본다
     /*
      * 상태줄이 보는 두 숫자.
@@ -269,6 +291,8 @@ export class Session {
     this.본것 = new 지켜본것();
     this.급정한것 = null;
     this.startedAt = Date.now();
+    /** 규칙 파일이 있는데 못 읽었나. `{이름, 까닭}` — /status 가 이걸 말한다. */
+    this.규칙못읽음 = null;
     this.rules = this.#loadRules();
     /*
      * 이 폴더가 무슨 프로젝트인가 (agent/project.js).
@@ -289,11 +313,27 @@ export class Session {
     this.memory = 기억토막(this.root);
   }
 
+  /**
+   * 이 폴더의 규칙 파일. DEEL.md → CLAUDE.md → AGENTS.md 중 먼저 읽히는 하나.
+   *
+   * 없는 것은 그냥 없는 것이라 아무 말도 안 한다. 그런데 **있는데 못 읽는**
+   * 것까지 같이 삼키면 안 된다 — 권한이 막혔거나 같은 이름의 폴더가 있으면
+   * 그렇게 된다. 사람은 규칙을 적어 뒀으니 걸려 있다고 믿는데 실제로는 하나도
+   * 안 걸린 채로 일이 돈다. 「운영 DB 는 건드리지 마라」 를 적어 놓고 그게
+   * 안 걸린 것이 여기서 나올 수 있는 제일 나쁜 모양이다.
+   * 못 읽은 것은 적어 두고 /status 가 '없음' 대신 그 까닭을 말한다.
+   */
   #loadRules() {
     for (const name of ['DEEL.md', 'CLAUDE.md', 'AGENTS.md']) {
-      const p = join(this.root, name);
-      if (existsSync(p)) {
-        try { return { name, text: readFileSync(p, 'utf8').slice(0, 20000) }; } catch {}
+      try { return { name, text: readFileSync(join(this.root, name), 'utf8').slice(0, 20000) }; }
+      catch (err) {
+        // 없으면 그냥 없는 것이다 — 말할 일이 아니다. existsSync 로 먼저 보지
+        // 않는 이유도 여기 있다: 보고 나서 읽는 사이에 지워지면 그 ENOENT 를
+        // 「있는데 못 읽었다」 로 적게 된다.
+        if (err?.code === 'ENOENT') continue;
+        // 첫 번째 것만 적어 둔다. 뒤엣것이 읽히면 그게 규칙이 되지만, 사람이
+        // 적어 둔 자리를 못 읽었다는 사실은 그래도 남아야 한다.
+        if (!this.규칙못읽음) this.규칙못읽음 = { 이름: name, 까닭: err?.code ?? err?.message ?? String(err) };
       }
     }
     return null;
@@ -505,6 +545,19 @@ export class Session {
     this.messages = 고침.messages;
     this.#턴표 = this.#턴표.filter((x) => this.messages.includes(x.표));
     this.#다음턴 = null;
+    /*
+     * 들고 있던 파일 내용도 같이 버린다. clear() 가 하는 것과 같은 까닭이다.
+     *
+     * 되감기는 그 턴의 Read 결과까지 대화에서 **진짜로 지운다.** 그런데 파일
+     * 기억은 그대로 남아서, 같은 파일을 다시 읽으면 「앞에서 읽은 그대로입니다」
+     * 나 「나머지는 앞에 실린 그대로입니다」 를 내민다 — 그 「앞엣것」 은 방금
+     * 이 줄이 지웠다.
+     *
+     * /undo 는 특히 그렇다. 파일을 고치고(기억에 담김) 되돌리면 디스크는 옛
+     * 모습으로 돌아가는데 기억은 고친 모습이라, 다시 읽을 때 있지도 않은 차이를
+     * 적어 보내게 된다. 여기서 한 줄 지우면 그냥 통째로 다시 읽는다.
+     */
+    this.파일기억?.잊기();
     return { 걷은것: 전 - this.messages.length, 고친것: 고침.고친것, 사람말, 턴: 표들.map((x) => x.턴) };
   }
 
@@ -517,6 +570,17 @@ export class Session {
   clear() {
     this.messages = [];
     this.filesRead.clear();
+    this.파일기억.잊기();
+    /*
+     * 할 일 목록과 시킨 말도 같이 버린다.
+     *
+     * 이 둘은 접거나 줄일 때 다시 박히는 것들이다(못박을것). 대화를 지운 뒤에도
+     * 들고 있으면, 새로 시작한 일이 처음 접히는 순간 **지운 대화의 할 일**이
+     * 되살아나 붙는다. 모델은 그걸 지금 시킨 것으로 알고 하러 간다 —
+     * 안 지운 것만 못하다.
+     */
+    this.할일 = [];
+    this.이번요청 = '';
     this.#턴표 = [];
     this.#다음턴 = null;
     return this;
@@ -725,13 +789,65 @@ export class Session {
     if (dropped <= 0) return 0;
     this.messages = [
       ...this.messages.slice(0, keepHead),
-      { role: 'user', content: `(앞선 대화 ${dropped}개를 줄였습니다. 필요하면 파일을 다시 읽으세요.)` },
+      {
+        role: 'user',
+        /*
+         * 줄일 때도 시킨 말과 남은 할 일을 다시 박는다.
+         *
+         * 이 길은 **요약을 못 받아 물러선** 길이다. 서버가 흔들릴 때 지나가는
+         * 길이라 제일 자주 밟히는데, 여태 여기에는 못 박는 것이 없었다.
+         * 머리 2개만 남기므로, 사용자가 세 번째 턴에서 네 가지를 시켰다면
+         * 그 네 가지가 그냥 사라진다. 접기(compact) 쪽에만 못 박아 두면
+         * 정작 제일 자주 지나가는 길에서만 조용히 어긋난다.
+         */
+        content: `(앞선 대화 ${dropped}개를 줄였습니다. 필요하면 파일을 다시 읽으세요.)\n\n` + 못박을것(this),
+      },
       ...this.messages.slice(keepTail),
     ];
     return dropped;
   }
 }
 
+/*
+ * ── 접거나 줄여도 이것만은 글자 그대로 남긴다 ──────────────────────────
+ *
+ * 요약은 요약이다. 네 가지를 적어 준 요청이 「네 가지를 고쳐 달라고 했다」
+ * 한 줄로 뭉개지고, **그 네 가지가 무엇이었는지는 사라진다.** 접힌 뒤로는
+ * 원문이 어디에도 없으니 남은 것을 이어 하려 해도 무엇이 남았는지 모른다.
+ *
+ * 할 일 목록도 같다. 목록이 사는 자리가 도구 결과 하나뿐이라, 55%에서 한 줄로
+ * 접히고 80%에서 요약에 뭉개진다. 접힘 문구는 「필요하면 다시 읽으세요」인데
+ * 할 일 목록은 **다시 읽을 파일이 없다.**
+ *
+ * 그래서 둘 다 접는 자리·줄이는 자리에서 다시 박는다. 끝난 항목은 안 싣는다 —
+ * 자리를 먹기만 하고, 이 쪽지가 답할 질문은 「무엇이 남았나」 하나다.
+ *
+ * compact.js 가 이 두 함수를 그대로 내보낸다. safeCut·safeHead 와 같은 까닭이다 —
+ * 접기와 줄이기가 **같은 것**을 박아야 하고, 한쪽만 고치면 물러서는 순간
+ * 대화가 어긋난다.
+ */
+const 못박을길이 = 1200;
+
+export function 못박은요청(session) {
+  const 원문 = String(session?.이번요청 ?? '').trim();
+  if (!원문) return '';
+  const 실을것 = 원문.length > 못박을길이
+    ? `${원문.slice(0, 못박을길이)}\n…(뒷부분 줄임)`
+    : 원문;
+  return `[이번에 시킨 말 — 요약이 아니라 원문 그대로입니다. 여기 적힌 것을 빠짐없이 하세요.]\n${실을것}\n\n`;
+}
+
+export function 못박은할일(session) {
+  const 남은 = (session?.할일 ?? []).filter((x) => x?.state !== 'done');
+  if (!남은.length) return '';
+  const 줄 = 남은.map((x) => `${x.state === 'doing' ? '▶ (하는 중)' : '☐'} ${String(x.text ?? '').trim()}`);
+  return `[아직 안 끝난 할 일 — 접히기 전 목록 그대로입니다. 이걸 이어서 하세요.]\n${줄.join('\n')}\n\n`;
+}
+
+export function 못박을것(session) {
+  return 못박은요청(session) + 못박은할일(session);
+}
+
 /**
  * 도구 호출과 결과가 갈라지지 않는 자리를 찾는다.
  * i 번째부터 남긴다고 할 때, 안전한 i 로 옮겨 준다.

package/src/agent/store.js

@@ -14,7 +14,7 @@
 //   마지막 줄까지는 성하다. 통째로 다시 쓰는 방식이면 그 순간 파일이 깨진다.
 import {
   existsSync, mkdirSync, readdirSync, readFileSync,
-  appendFileSync, writeFileSync, statSync, rmSync,
+  appendFileSync, writeFileSync, statSync, rmSync, chmodSync,
 } from 'node:fs';
 import { join } from 'node:path';
 
@@ -51,19 +51,93 @@ export class Store {
     this.auto = id == null;      // 우리가 지은 이름인가 (그러면 겹칠 때 바꿔도 된다)
     this.#use(id ?? freeId(this.dir));
     this.opened = false;
+    /** 적으려다 못 적은 줄 수와 첫 까닭. 0 이 아니면 이 대화는 반만 남는다. */
+    this.못쓴수 = 0;
+    this.못쓴까닭 = null;
+    this.말한적있나 = false;
+    // 이 파일과 묶인 대화, 그리고 그 대화에서 **마지막으로 적어 둔** 할 일·시킨 말.
+    // 안 바뀐 것을 다시 적지 않으려고 들고 있는다 (살림적기).
+    this.따라갈세션 = null;
+    this.적은할일 = null;
+    this.적은요청 = null;
   }
 
   #use(id) {
     this.id = id;
     this.file = join(this.dir, `${id}.jsonl`);
+    this.#잠갔나 = false;      // 다른 파일로 옮겨 갔으면 그 파일은 아직 안 잠갔다
+  }
+
+  /*
+   * 만든 뒤 본인만 읽게 잠근다 (config.js 가 설정 파일에 하는 것과 같다).
+   *
+   * 여기 남는 것은 대화 전체다 — 사람이 붙여 넣은 글, 읽은 파일 내용, 모델이
+   * 쓴 답. 홈이 공유 폴더에 있거나 같은 PC 를 여럿이 쓰면 그게 그대로 읽힌다.
+   * 한 번만 건다. 윈도우(NTFS)에서는 chmod 가 아무 일도 안 한다 — 거기서는
+   * 못 잠근 것이지 잠근 척하지 않는다.
+   *
+   * 건 결과를 `잠금` 에 남긴다. "본인만 읽게 잠근다" 는 말은 지켜지는지
+   * **밖에서 볼 수 있어야** 뜻이 있다 (keystore.js 의 마지막명령줄 과 같은
+   * 까닭). 윈도우에서 값이 남는다고 실제로 잠겼다는 뜻은 아니다.
+   */
+  #잠갔나 = false;
+  /** 파일 권한을 건 결과. `{모드}` 면 걸었고, `{못함}` 이면 못 걸었다. */
+  잠금 = null;
+  #잠그기() {
+    if (this.#잠갔나) return;
+    this.#잠갔나 = true;
+    try { chmodSync(this.file, 0o600); this.잠금 = { 모드: 0o600 }; }
+    catch (err) { this.잠금 = { 못함: err?.code ?? String(err) }; }
   }
 
   #open() {
     if (this.opened) return;
-    mkdirSync(this.dir, { recursive: true });
+    // 폴더를 못 만들어도 여기서 던지지 않는다. 던지면 대화 자체가 그 자리에서
+    // 끊긴다 — 기록을 남기려다 작업을 죽이면 본말이 뒤집힌다.
+    // 조용히 넘기는 것도 아니다: 폴더가 없으면 바로 아래 쓰기가 깨지고,
+    // 그 자리에서 세어 화면에 오른다.
+    try { mkdirSync(this.dir, { recursive: true }); } catch { /* 아래 쓰기가 센다 */ }
     this.opened = true;
   }
 
+  /*
+   * 못 적은 것을 세어 둔다.
+   *
+   * 이 파일 첫 줄이 파는 문장이 「껐다 켜도 이어서 하게 한다」 이고, /sessions
+   * 화면은 대놓고 「지금 대화는 나가지 않아도 계속 저장되고 있습니다」 라고
+   * 적어 준다. 디스크가 차거나 홈이 읽기 전용이거나 파일을 누가 잡고 있으면
+   * 그 두 문장이 거짓이 되는데, 여태 화면은 아무 말이 없었다.
+   *
+   * 그 침묵이 비싼 까닭: 사람이 알아차리는 자리가 **다음 날 --resume** 이다.
+   * 그때는 이미 대화가 없고, 되돌릴 방법도 없다. 안 적히고 있다는 것만 그때
+   * 알았어도 창을 안 닫거나 중요한 것을 따로 적어 뒀을 것이다.
+   * 감사기록(safety/audit.js)에서 한 것과 같은 방식으로 세어 둔다.
+   */
+  #못썼다(err) {
+    this.못쓴수 += 1;
+    // 까닭은 코드가 먼저다 — EACCES·ENOSPC 한 낱말이 긴 문장보다 알아보기 쉽고,
+    // 파일 경로가 섞여 들어가지 않아 화면 한 줄에 들어간다.
+    if (!this.못쓴까닭) this.못쓴까닭 = err?.code ?? err?.message ?? String(err);
+  }
+
+  /** 저장이 새고 있나. 새고 있으면 `{수, 까닭}`, 멀쩡하면 null. */
+  못쓴것() {
+    return this.못쓴수 ? { 수: this.못쓴수, 까닭: this.못쓴까닭 } : null;
+  }
+
+  /**
+   * 화면이 **한 번만** 말하게 하려고 쓴다. 처음 물어볼 때만 알려 주고 그 뒤로는 null.
+   *
+   * 한 줄 못 적을 때마다 경고를 찍으면 사람은 이틀 만에 그 줄을 안 읽게 되고,
+   * 그러면 정작 처음 한 번도 못 읽힌다. 세어 둔 값(못쓴것)은 안 지운다 —
+   * /sessions 화면은 언제 열어도 지금 몇 건인지 말해야 한다.
+   */
+  처음못쓴것() {
+    if (!this.못쓴수 || this.말한적있나) return null;
+    this.말한적있나 = true;
+    return this.못쓴것();
+  }
+
   /**
    * 첫 줄은 머리글 — 어떤 모델·어떤 폴더에서 한 대화인지.
    *
@@ -77,9 +151,12 @@ export class Store {
     for (let tries = 0; tries < 50; tries++) {
       try {
         writeFileSync(this.file, head, { encoding: 'utf8', flag: 'wx' });
+        this.#잠그기();
         return this;
       } catch (err) {
-        if (err?.code !== 'EEXIST') return this;   // 못 적어도 대화는 계속돼야 한다
+        // 못 적어도 대화는 계속돼야 한다. 다만 조용히 넘기지는 않는다 —
+        // 머리글을 못 적었으면 그 뒤의 줄도 십중팔구 못 적는다.
+        if (err?.code !== 'EEXIST') { this.#못썼다(err); return this; }
         if (!this.auto) return this;               // 이어쓰기 — 이미 있는 게 맞다
         this.#use(freeId(this.dir));               // 누가 채 갔다. 옆자리로.
       }
@@ -88,14 +165,78 @@ export class Store {
   }
 
   #write(obj) {
-    try { appendFileSync(this.file, JSON.stringify(obj) + '\n', 'utf8'); }
-    catch { /* 기록에 실패해도 대화는 계속돼야 한다 */ }
+    try {
+      appendFileSync(this.file, JSON.stringify(obj) + '\n', 'utf8');
+      this.#잠그기();
+    } catch (err) { this.#못썼다(err); }   // 계속은 하되, 몇 줄을 잃었는지는 센다
   }
 
   // 메시지 하나를 덧붙인다. 대화가 진행되는 대로 즉시 남긴다.
   append(msg) {
     this.#open();
     this.#write({ t: 'msg', m: msg });
+    // 남은 할 일과 시킨 말도 이 자리에서 같이 본다 (아래 살림적기).
+    // 따로 부르는 자리를 만들면 언젠가 한 길에서만 부르게 되고, 그 길로 들어온
+    // 사람만 이어하기가 반쪽이 된다.
+    this.살림적기();
+  }
+
+  /*
+   * ── 남은 할 일과 시킨 말 원문 ──────────────────────────────────────────
+   *
+   * 1.9.2 는 **한 대화 안에서** 이 둘이 접히거나 줄어들며 사라지던 것을 막았다
+   * (session.js 의 못박을것). 그런데 둘 다 세션 객체, 곧 메모리에만 있어서
+   * 창을 닫는 한 번에 그 보호가 통째로 없어졌다 — 이어받으면 오간 말은 돌아오고
+   * 못 박은 것도 돌아오는데, 남은 할 일과 시킨 말 원문만 안 돌아온다.
+   * 「요청사항이 많으면 몇 개 까먹는다」 가 껐다 켜는 자리에서 되풀이된다.
+   *
+   * 메시지와 따로 한 줄로 두는 이유는 pins 와 같다 — 접기·요약은 메시지를
+   * 손보는데 이 둘은 그 손질에 닿으면 안 된다. 마지막 것이 이긴다.
+   */
+
+  /**
+   * 이 대화의 할 일·시킨 말을 이 저장 파일과 묶는다.
+   *
+   * 처음 묶을 때 파일에 적힌 것을 세션으로 되살린다 — 이어하기의 빠져 있던
+   * 절반이 여기다. 그 뒤로는 append 가 돌 때마다 **바뀐 만큼만** 적는다.
+   */
+  살림따라가기(session) {
+    if (!session) return this;
+    const 처음 = this.따라갈세션 !== session;
+    this.따라갈세션 = session;
+    if (처음) this.#살림되살리기(session);
+    return this;
+  }
+
+  #살림되살리기(session) {
+    const { 할일, 이번요청 } = this.load();
+    // 적힌 것이 없으면 세션이 들고 있던 것을 그대로 둔다. 빈 값으로 덮으면
+    // 새 갈래를 열자마자 방금 시킨 말이 사라진다 — 갈래마다 파일이 따로다.
+    if (할일) session.할일 = 할일;
+    if (이번요청) session.이번요청 = 이번요청;
+    this.적은할일 = JSON.stringify(session.할일 ?? []);
+    this.적은요청 = String(session.이번요청 ?? '');
+  }
+
+  /**
+   * 바뀐 것만 적는다. 안 바뀌었으면 한 줄도 안 늘린다.
+   *
+   * 메시지마다 목록을 통째로 다시 적으면 긴 대화에서 파일이 몇 배가 되고,
+   * 그 값은 매번 사람이 기다리는 시간이다. pins 를 사람이 고칠 때만 적는
+   * 것과 같은 뜻이다.
+   */
+  살림적기(session = this.따라갈세션) {
+    if (!session) return;
+    const 할일 = JSON.stringify(session.할일 ?? []);
+    if (할일 !== this.적은할일) {
+      this.적은할일 = 할일;
+      this.#write({ t: 'todo', at: new Date().toISOString(), 목록: session.할일 ?? [] });
+    }
+    const 요청 = String(session.이번요청 ?? '');
+    if (요청 !== this.적은요청) {
+      this.적은요청 = 요청;
+      this.#write({ t: 'request', at: new Date().toISOString(), 글: 요청 });
+    }
   }
 
   /**
@@ -132,11 +273,31 @@ export class Store {
     // 여기가 놓치기 쉬운 자리다. 파일을 새로 쓰면서 못 박은 것을 안 옮기면,
     // '요약해도 안 지워진다' 는 말이 바로 그 요약에서 거짓이 된다.
     const 못박은것 = this.못박은것읽기();
+    // 남은 할 일과 시킨 말 원문도 같은 이유로 옮겨 싣는다. 접힌 자리에서
+    // 다시 박으라고 들고 있는 것들인데, 정작 접는 자리에서 파일에서 빠지면
+    // 이어받을 때 그 둘만 없는 대화가 된다.
+    //
+    // 옮겨 싣기 **전에** 아직 안 적은 것을 먼저 적는다. 여기서 파일만 보고
+    // 옮기면, 메시지가 한 번도 안 붙은 사이에 할 일이 바뀐 경우 그 바뀐 것이
+    // 통째로 사라진다 — 접는 자리는 원래 제일 크게 잃는 자리다.
+    this.살림적기();
+    const { 할일, 이번요청 } = this.load();
     const lines = [JSON.stringify({ t: 'meta', at: new Date().toISOString(), ...meta })];
     lines.push(JSON.stringify({ t: 'note', at: new Date().toISOString(), note }));
     if (못박은것.length) lines.push(JSON.stringify({ t: 'pins', at: new Date().toISOString(), 목록: 못박은것 }));
+    if (할일) lines.push(JSON.stringify({ t: 'todo', at: new Date().toISOString(), 목록: 할일 }));
+    if (이번요청) lines.push(JSON.stringify({ t: 'request', at: new Date().toISOString(), 글: 이번요청 }));
     for (const m of messages) lines.push(JSON.stringify({ t: 'msg', m }));
-    try { writeFileSync(this.file, lines.join('\n') + '\n', 'utf8'); } catch {}
+    /*
+     * 통째로 다시 쓰면 파일이 새로 만들어진다 — 그때 잠금도 다시 걸어야 한다.
+     * 그리고 여기서 깨지면 앞의 append 들이 남긴 것까지 통째로 못 고친 셈이
+     * 된다. 제일 크게 잃는 자리라 더더욱 조용히 넘길 수 없다.
+     */
+    try {
+      writeFileSync(this.file, lines.join('\n') + '\n', 'utf8');
+      this.#잠갔나 = false;
+      this.#잠그기();
+    } catch (err) { this.#못썼다(err); }
   }
 
   readMeta() {
@@ -148,19 +309,35 @@ export class Store {
     } catch { return null; }
   }
 
-  // 저장된 대화를 읽어 온다. 깨진 줄은 건너뛴다 — 도중에 죽었을 수 있다.
+  /**
+   * 저장된 대화를 읽어 온다. 깨진 줄은 건너뛴다 — 도중에 죽었을 수 있다.
+   *
+   * 파일을 아예 못 여는 경우(권한, 다른 프로그램이 잡고 있음)에도 던지지 않는다.
+   * 이 함수는 list() 가 폴더의 대화를 하나씩 훑으면서 부른다. 한 파일에서
+   * 던지면 **목록 화면 전체가 안 뜨고**, 멀쩡히 이어할 수 있는 나머지 대화까지
+   * 사람 눈에서 사라진다. 못 읽은 것은 못읽음 에 까닭을 담아 알린다.
+   */
   load() {
     if (!existsSync(this.file)) return { meta: null, messages: [] };
+    let 글;
+    try { 글 = readFileSync(this.file, 'utf8'); }
+    catch (err) { return { meta: null, messages: [], 못읽음: err?.code ?? err?.message ?? String(err) }; }
     let meta = null;
     const messages = [];
-    for (const line of readFileSync(this.file, 'utf8').split('\n')) {
+    // 마지막 것이 이긴다. 없으면 null 이고, null 은 '적힌 적이 없다' 는 뜻이라
+    // 빈 목록·빈 글과 구별된다 — 되살릴 때 그 차이로 덮을지 말지를 정한다.
+    let 할일 = null;
+    let 이번요청 = null;
+    for (const line of 글.split('\n')) {
       if (!line.trim()) continue;
       let j;
       try { j = JSON.parse(line); } catch { continue; }
       if (j.t === 'meta') meta = j;
       else if (j.t === 'msg' && j.m) messages.push(j.m);
+      else if (j.t === 'todo' && Array.isArray(j.목록)) 할일 = j.목록;
+      else if (j.t === 'request' && typeof j.글 === 'string') 이번요청 = j.글;
     }
-    return { meta, messages };
+    return { meta, messages, 할일, 이번요청 };
   }
 }
 

package/src/agent/threads.js

@@ -40,7 +40,19 @@ export class Threads {
     this.session = session;
     this.ctx = ctx;
     this.새store = 새store;
-    this.갈래들 = [{ 이름: '본줄기', messages: session.messages, usage: session.usage, todos: ctx?.todos ?? null, store: 첫store }];
+    /*
+     * 남은 할 일과 시킨 말 원문을 저장 파일과 묶는다 (agent/store.js 의 살림따라가기).
+     *
+     * **첫 한마디가 오기 전**인 여기여야 한다. 턴이 시작되면 loop.js 가
+     * 이번요청을 새 말로 덮으므로, 그 뒤에 되살리면 방금 시킨 말이 어제 시킨
+     * 말로 되돌아간다. 여태 이 둘만 메모리에 있어서, 이어받아도 오간 말은
+     * 돌아오는데 남은 할 일은 안 돌아왔다.
+     */
+    첫store?.살림따라가기?.(session);
+    this.갈래들 = [{
+      이름: '본줄기', messages: session.messages, usage: session.usage, todos: ctx?.todos ?? null,
+      할일: session.할일, 이번요청: session.이번요청, store: 첫store,
+    }];
     this.자리 = 0;
     this.센것 = 1;
   }
@@ -55,6 +67,11 @@ export class Threads {
     g.messages = this.session.messages;
     g.usage = this.session.usage;
     g.todos = this.ctx?.todos ?? null;
+    // 남은 할 일·시킨 말도 갈래 것이다. 저장 파일이 갈래마다 따로라, 이걸 안
+    // 담아 두면 곁가지에서 적은 할 일을 들고 본줄기로 돌아와 본줄기 파일에
+    // 적어 버린다 — 이어받을 때 하지도 않은 일이 본줄기에 남는다.
+    g.할일 = this.session.할일;
+    g.이번요청 = this.session.이번요청;
   }
 
   /** 갈래 하나를 화면으로 꺼낸다. */
@@ -64,6 +81,10 @@ export class Threads {
     this.session.messages = g.messages;
     this.session.usage = g.usage;
     if (this.ctx) this.ctx.todos = g.todos;
+    this.session.할일 = g.할일 ?? [];
+    this.session.이번요청 = g.이번요청 ?? '';
+    // 적는 자리도 지금 갈래의 파일로 옮긴다 (agent/store.js 의 살림따라가기).
+    g.store?.살림따라가기?.(this.session);
     // 상태줄이 지금 어느 갈래인지 보여 줄 수 있게 남긴다.
     // 갈래가 하나뿐이면 안 보인다 — 안 쓰는 사람 화면은 그대로여야 한다.
     this.session.갈래표 = this.갈래들.length > 1 ? g.이름 : null;
@@ -84,6 +105,10 @@ export class Threads {
       messages: 물려줄것 ? [...물려줄것] : [],
       usage: { in: 0, out: 0, calls: 0, ms: 0, retries: 0 },
       todos: null,
+      // 할 일도 todos 와 같이 비워서 시작한다. 곁가지는 다른 일을 하러 나가는
+      // 것이고, 물려받으면 본줄기의 남은 일을 곁가지 파일에도 적게 된다.
+      할일: [],
+      이번요청: '',
       store,
     };
     this.갈래들.push(g);