@zhongqian97-code/ecode 0.3.12 → 0.5.1

package/README.md

@@ -154,6 +154,50 @@ Type `/` to see available skills with Tab autocomplete. Skills inject structured
 
 Run `/setup-matt-pocock-skills` once to configure the issue tracker and triage vocabulary for your repo.
 
+## Automation: /loop and /goal
+
+Run LLM tasks automatically — on a schedule or until a condition is met.
+
+### /loop — recurring tasks
+
+```
+/loop [interval] <prompt>
+```
+
+Runs the prompt on a fixed interval. Interval formats: `30s`, `5m`, `1h`, `1h30m`. Defaults to 5 minutes if omitted.
+
+```
+/loop 10m check git status and summarize uncommitted changes
+/loop 1h summarize today's work and update CHANGELOG
+```
+
+### /goal — condition-driven tasks
+
+```
+/goal <condition>
+```
+
+Runs the condition as both the prompt and the success criterion. The LLM executes the prompt, then a separate evaluator LLM judges whether the condition has been met. Repeats until `done` or `blocked`.
+
+```
+/goal all TypeScript errors are fixed
+/goal the test suite passes with no failures
+```
+
+### Managing jobs
+
+```
+/jobs              — list all active jobs
+/unloop <id>       — cancel a loop job (use first 8 chars of id)
+/ungoal <id>       — cancel a goal job
+```
+
+### Data storage
+
+Job state and run logs are stored in `<ECODE_LOG_DIR>/automation/` (or `~/.config/ecode/automation/` if no log dir is set). Jobs survive restarts — they resume automatically on next launch.
+
+---
+
 ## Session logging
 
 Enable JSONL session logs to replay or analyze conversations:
@@ -167,7 +211,27 @@ ecode
 # "logDir": "~/.ecode/logs"
 ```
 
-Each session writes a timestamped `.jsonl` file. Each line is a JSON object with `role`, `content`, and `timestamp`.
+Each session writes a timestamped `.jsonl` log file and a companion `-session.json` metadata file (id, title, model, token count, turn count).
+
+### `ecode sessions` subcommands
+
+```bash
+# list all sessions, sorted by most recent activity
+ecode sessions list
+
+# show full metadata for a session (use 8-char prefix or full UUID)
+ecode sessions inspect a1b2c3d4
+
+# get a shell command to replay a session
+ecode sessions replay a1b2c3d4
+# → ecode --replay ~/.ecode/logs/2026-05-13T08-47-00.jsonl
+
+# get a shell command to fork a session at a specific turn (default: last turn)
+ecode sessions fork a1b2c3d4 5
+# → ecode --fork ~/.ecode/logs/2026-05-13T08-47-00.jsonl:5
+```
+
+The `fork` command is the basis for `/goal` rollback: when the evaluator detects context drift, it surfaces a `sessions fork` command pointing to the last known-good turn.
 
 ## Requirements
 

package/dist/index.js

@@ -3,11 +3,11 @@ const _ew=process.emitWarning.bind(process);process.emitWarning=function(w,...a)
 
 // src/index.ts
 import { createRequire } from "module";
-import { resolve as resolve4, dirname as dirname6 } from "path";
+import { resolve as resolve4, dirname as dirname7 } from "path";
 import { fileURLToPath } from "url";
 import React4 from "react";
 import { render } from "ink";
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 
 // src/config.ts
 import { existsSync, readFileSync } from "fs";
@@ -537,13 +537,13 @@ var READ_TOOL = {
   }
 };
 async function readFile2(params) {
-  const { path: path7, offset = 0, limit } = params;
+  const { path: path9, offset = 0, limit } = params;
   let raw;
   try {
-    raw = await fs.readFile(path7, "utf8");
+    raw = await fs.readFile(path9, "utf8");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    return `Error reading ${path7}: ${msg}`;
+    return `Error reading ${path9}: ${msg}`;
   }
   const lines = raw.split("\n");
   const sliced = limit !== void 0 ? lines.slice(offset, offset + limit) : lines.slice(offset);
@@ -599,28 +599,28 @@ var EDIT_TOOL = {
   }
 };
 async function editFile(params) {
-  const { path: path7, old_string, new_string } = params;
+  const { path: path9, old_string, new_string } = params;
   let content;
   try {
-    content = await fs3.readFile(path7, "utf8");
+    content = await fs3.readFile(path9, "utf8");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    return `Error reading ${path7}: ${msg}`;
+    return `Error reading ${path9}: ${msg}`;
   }
   const count = countOccurrences(content, old_string);
   if (count === 0) {
-    return `Error: old_string not found in ${path7}`;
+    return `Error: old_string not found in ${path9}`;
   }
   if (count > 1) {
-    return `Error: old_string appears ${count} times in ${path7} (ambiguous \u2014 add more context)`;
+    return `Error: old_string appears ${count} times in ${path9} (ambiguous \u2014 add more context)`;
   }
   const updated = content.replace(old_string, new_string);
   try {
-    await fs3.writeFile(path7, updated, "utf8");
-    return `Edited ${path7}`;
+    await fs3.writeFile(path9, updated, "utf8");
+    return `Edited ${path9}`;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    return `Error writing ${path7}: ${msg}`;
+    return `Error writing ${path9}: ${msg}`;
   }
 }
 function countOccurrences(haystack, needle) {
@@ -2126,8 +2126,735 @@ function parseMouseScroll(data) {
   return null;
 }
 
+// src/ui/App.tsx
+import { homedir as homedir2 } from "os";
+import { join as join10 } from "path";
+
+// src/automation/store.ts
+import { readFile as readFile8, writeFile as writeFile5, mkdir as mkdir2 } from "fs/promises";
+import { join as join7 } from "path";
+function jobsFilePath(dataDir) {
+  return join7(dataDir, "jobs.json");
+}
+async function loadJobs(dataDir) {
+  try {
+    const content = await readFile8(jobsFilePath(dataDir), "utf-8");
+    const parsed = JSON.parse(content);
+    if (!Array.isArray(parsed)) return [];
+    return parsed;
+  } catch {
+    return [];
+  }
+}
+async function saveJobs(dataDir, jobs) {
+  await mkdir2(dataDir, { recursive: true });
+  await writeFile5(jobsFilePath(dataDir), JSON.stringify(jobs, null, 2), "utf-8");
+}
+async function upsertJob(dataDir, job) {
+  const jobs = await loadJobs(dataDir);
+  const idx = jobs.findIndex((j) => j.id === job.id);
+  if (idx >= 0) {
+    const updated = [...jobs.slice(0, idx), job, ...jobs.slice(idx + 1)];
+    await saveJobs(dataDir, updated);
+  } else {
+    await saveJobs(dataDir, [...jobs, job]);
+  }
+}
+async function removeJob(dataDir, id) {
+  const jobs = await loadJobs(dataDir);
+  const target = jobs.find((j) => j.id === id);
+  if (!target) return void 0;
+  await saveJobs(dataDir, jobs.filter((j) => j.id !== id));
+  return target;
+}
+
+// src/automation/runtime.ts
+import { randomUUID } from "crypto";
+
+// src/automation/log.ts
+import { readFile as readFile9, appendFile, mkdir as mkdir3 } from "fs/promises";
+import { join as join8 } from "path";
+function logFilePath(logDir) {
+  return join8(logDir, "automation-runs.jsonl");
+}
+async function appendRunLog(logDir, entry) {
+  await mkdir3(logDir, { recursive: true });
+  await appendFile(logFilePath(logDir), JSON.stringify(entry) + "\n", "utf-8");
+}
+
+// src/automation/runtime.ts
+async function executeJob(job, config2) {
+  if (job.budget?.maxTurns !== void 0 && job.runCount >= job.budget.maxTurns) {
+    return null;
+  }
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const runId = randomUUID();
+  let summaryText;
+  let errorMsg;
+  let result;
+  try {
+    summaryText = await config2.session.run(job.promptTemplate);
+    result = "success";
+  } catch (err) {
+    errorMsg = err instanceof Error ? err.message : String(err);
+    result = "failure";
+  }
+  const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const entry = {
+    id: runId,
+    jobId: job.id,
+    startedAt,
+    finishedAt,
+    promptUsed: job.promptTemplate,
+    result,
+    summaryText,
+    error: errorMsg
+  };
+  await appendRunLog(config2.logDir, entry);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const updatedJob = {
+    ...job,
+    runCount: job.runCount + 1,
+    failureCount: result === "failure" ? job.failureCount + 1 : job.failureCount,
+    lastRunAt: finishedAt,
+    lastError: errorMsg,
+    updatedAt: now
+  };
+  await upsertJob(config2.dataDir, updatedJob);
+  return entry;
+}
+
+// src/automation/goal/evaluator.ts
+function parseVerdict(response) {
+  const lower = response.toLowerCase();
+  if (lower.includes("not_done")) return "not_done";
+  if (lower.includes("blocked")) return "blocked";
+  if (lower.includes("done")) return "done";
+  return "not_done";
+}
+function buildPrompt(input) {
+  return [
+    "You are evaluating whether a goal condition has been met based on a work transcript.",
+    "",
+    `Goal condition: ${input.condition}`,
+    "",
+    "Work transcript:",
+    input.transcript,
+    "",
+    'Reply with one of these verdicts: "done", "not_done", or "blocked".',
+    '"done" means the condition is satisfied.',
+    '"not_done" means the condition is not yet satisfied but work can continue.',
+    '"blocked" means progress is impossible due to an error or blocker.',
+    "After the verdict, explain your reasoning briefly."
+  ].join("\n");
+}
+function createLLMEvaluator(session) {
+  return {
+    async evaluate(input) {
+      try {
+        const prompt = buildPrompt(input);
+        const response = await session.run(prompt);
+        const verdict = parseVerdict(response);
+        return { verdict, reason: response };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { verdict: "blocked", reason: message };
+      }
+    }
+  };
+}
+
+// src/automation/loop/scheduler.ts
+var LoopScheduler = class {
+  options;
+  /** 按 jobId 索引的调度表 */
+  entries = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * 初始化调度器，传入初始 job 列表
+   * 每个 job 会被立即纳入调度
+   */
+  start(jobs) {
+    for (const job of jobs) {
+      this.scheduleJob(job);
+    }
+  }
+  /**
+   * 停止所有调度，清除全部挂起的 timer
+   */
+  stop() {
+    for (const entry of this.entries.values()) {
+      if (entry.timerId !== void 0) {
+        clearTimeout(entry.timerId);
+        entry.timerId = void 0;
+      }
+    }
+    this.entries.clear();
+  }
+  /**
+   * 动态添加一个新 job 并立即纳入调度
+   */
+  add(job) {
+    const existing = this.entries.get(job.id);
+    if (existing?.timerId !== void 0) {
+      clearTimeout(existing.timerId);
+    }
+    this.scheduleJob(job);
+  }
+  /**
+   * 按 id 移除 job 并取消其挂起的 timer
+   * id 不存在时静默忽略，不抛出异常
+   */
+  remove(id) {
+    const entry = this.entries.get(id);
+    if (entry === void 0) return;
+    if (entry.timerId !== void 0) {
+      clearTimeout(entry.timerId);
+    }
+    this.entries.delete(id);
+  }
+  /**
+   * 获取指定 job 的下次运行时间（ISO 字符串）
+   * job 不存在时返回 undefined
+   */
+  getNextRunAt(jobId) {
+    const entry = this.entries.get(jobId);
+    if (entry === void 0) return void 0;
+    return new Date(entry.nextRunAtMs).toISOString();
+  }
+  // ──────────────────────────────────────────────────────────────
+  // 私有方法
+  // ──────────────────────────────────────────────────────────────
+  /**
+   * 将 job 纳入调度：
+   * 1. 计算第一次触发的延迟
+   * 2. 若 nextRunAt 已过期，快速推进到下一个未来时间（不补跑）
+   * 3. 挂起 setTimeout
+   */
+  scheduleJob(job) {
+    const now = Date.now();
+    let nextRunAtMs = new Date(job.nextRunAt).getTime();
+    if (nextRunAtMs <= now) {
+      const { intervalMs } = job;
+      nextRunAtMs += intervalMs;
+      while (nextRunAtMs <= now) {
+        nextRunAtMs += intervalMs;
+      }
+    }
+    const entry = {
+      job,
+      nextRunAtMs,
+      timerId: void 0
+    };
+    this.entries.set(job.id, entry);
+    this.arm(entry);
+  }
+  /**
+   * 为 entry 挂起一个 setTimeout，延迟到 entry.nextRunAtMs
+   */
+  arm(entry) {
+    const delay = Math.max(0, entry.nextRunAtMs - Date.now());
+    entry.timerId = setTimeout(() => {
+      void this.fire(entry);
+    }, delay);
+  }
+  /**
+   * job 到期时的触发逻辑：
+   * 1. 检查 TTL，若已过期则不执行、不重新调度
+   * 2. 调用 onJobRun；失败时调用 onJobError
+   * 3. 无论成功失败，均重新调度下一次（TTL 由下次触发时再判断）
+   */
+  async fire(entry) {
+    const { job } = entry;
+    const now = Date.now();
+    if (job.ttlMs !== void 0) {
+      const expiresAt = new Date(job.createdAt).getTime() + job.ttlMs;
+      if (now >= expiresAt) {
+        this.entries.delete(job.id);
+        return;
+      }
+    }
+    try {
+      await this.options.onJobRun(job);
+    } catch (error) {
+      this.options.onJobError(job, error);
+    }
+    const current = this.entries.get(job.id);
+    if (current === void 0) return;
+    current.nextRunAtMs = Date.now() + job.intervalMs;
+    this.arm(current);
+  }
+};
+
+// src/automation/loop/command.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/automation/loop/parse.ts
+var DEFAULT_INTERVAL_MS = 6e5;
+var MIN_INTERVAL_MS = 3e4;
+var UNIT_MS = {
+  s: 1e3,
+  m: 6e4,
+  h: 36e5
+};
+var TIME_TOKEN_RE = /(\d+)\s*([smh])/gi;
+function parseInterval(input) {
+  if (input == null) return { intervalMs: DEFAULT_INTERVAL_MS };
+  const trimmed = input.trim();
+  if (trimmed === "") return { intervalMs: DEFAULT_INTERVAL_MS };
+  if (trimmed.startsWith("-")) return null;
+  const normalized = trimmed.replace(/^every\s+/i, "");
+  if (/^\d+$/.test(normalized)) {
+    const ms = parseInt(normalized, 10) * 1e3;
+    return ms > 0 && ms >= MIN_INTERVAL_MS ? { intervalMs: ms } : null;
+  }
+  let totalMs = 0;
+  let matchCount = 0;
+  TIME_TOKEN_RE.lastIndex = 0;
+  let match;
+  while ((match = TIME_TOKEN_RE.exec(normalized)) !== null) {
+    const value = parseInt(match[1], 10);
+    const unit = match[2].toLowerCase();
+    totalMs += value * UNIT_MS[unit];
+    matchCount++;
+  }
+  if (matchCount === 0) return null;
+  if (totalMs <= 0 || totalMs < MIN_INTERVAL_MS) return null;
+  return { intervalMs: totalMs };
+}
+
+// src/automation/loop/command.ts
+function formatInterval(ms) {
+  const totalSec = Math.floor(ms / 1e3);
+  const h = Math.floor(totalSec / 3600);
+  const m = Math.floor(totalSec % 3600 / 60);
+  const s = totalSec % 60;
+  if (h > 0 && m === 0 && s === 0) return `${h}h`;
+  if (h > 0 && s === 0) return `${h}h${m}m`;
+  if (h > 0) return `${h}h${m}m${s}s`;
+  if (m > 0 && s === 0) return `${m}m`;
+  if (m > 0) return `${m}m${s}s`;
+  return `${s}s`;
+}
+async function cmdLoop(args, deps) {
+  const trimmed = args.trim();
+  let intervalMs = DEFAULT_INTERVAL_MS;
+  let prompt = trimmed;
+  const spaceIdx = trimmed.indexOf(" ");
+  if (spaceIdx !== -1) {
+    const firstToken = trimmed.slice(0, spaceIdx);
+    const parsed = parseInterval(firstToken);
+    if (parsed !== null) {
+      intervalMs = parsed.intervalMs;
+      prompt = trimmed.slice(spaceIdx + 1).trim();
+    }
+  }
+  const now = /* @__PURE__ */ new Date();
+  const job = {
+    id: randomUUID2(),
+    kind: "loop",
+    title: prompt.slice(0, 60),
+    createdAt: now.toISOString(),
+    updatedAt: now.toISOString(),
+    state: "scheduled",
+    promptTemplate: prompt,
+    intervalMs,
+    nextRunAt: new Date(now.getTime() + intervalMs).toISOString(),
+    autoRunNow: false,
+    runCount: 0,
+    failureCount: 0
+  };
+  await upsertJob(deps.dataDir, job);
+  deps.onSchedule(job);
+  return `\u5DF2\u521B\u5EFA loop job [${job.id.slice(0, 8)}]\uFF0C\u6BCF ${formatInterval(intervalMs)} \u6267\u884C\u4E00\u6B21\uFF1A${prompt}`;
+}
+async function cmdJobs(deps) {
+  const jobs = await loadJobs(deps.dataDir);
+  if (jobs.length === 0) {
+    return "\u6682\u65E0 automation job\u3002\u4F7F\u7528 /loop <interval> <prompt> \u521B\u5EFA\u4E00\u4E2A\u3002";
+  }
+  const lines = jobs.map((j) => {
+    const interval = j.kind === "loop" ? formatInterval(j.intervalMs) : "\u2014";
+    const idPrefix = j.id.slice(0, 8);
+    return `[${idPrefix}] ${interval}  ${j.promptTemplate}  (${j.state})`;
+  });
+  return `\u5F53\u524D job \u5217\u8868\uFF08\u5171 ${jobs.length} \u4E2A\uFF09\uFF1A
+${lines.join("\n")}`;
+}
+async function cmdUnloop(idOrPrefix, deps) {
+  const jobs = await loadJobs(deps.dataDir);
+  const target = jobs.find(
+    (j) => j.id === idOrPrefix || j.id.startsWith(idOrPrefix)
+  );
+  if (target === void 0) {
+    return `\u627E\u4E0D\u5230 job "${idOrPrefix}"\uFF0C\u8BF7\u7528 /jobs \u786E\u8BA4 id\u3002`;
+  }
+  await removeJob(deps.dataDir, target.id);
+  deps.onUnschedule(target.id);
+  return `\u5DF2\u53D6\u6D88 loop job [${target.id.slice(0, 8)}]\uFF1A${target.promptTemplate}`;
+}
+
+// src/automation/goal/command.ts
+import { randomUUID as randomUUID3 } from "crypto";
+async function cmdGoal(args, deps) {
+  const condition = args.trim();
+  const now = /* @__PURE__ */ new Date();
+  const job = {
+    id: randomUUID3(),
+    kind: "goal",
+    title: condition.slice(0, 60),
+    createdAt: now.toISOString(),
+    updatedAt: now.toISOString(),
+    state: "scheduled",
+    promptTemplate: condition,
+    condition,
+    activeTurnCount: 0,
+    runCount: 0,
+    failureCount: 0,
+    // 快照字段：仅在调用方提供时写入，旧格式兼容（undefined 即不存在）
+    snapshotLogFile: deps.snapshotLogFile,
+    snapshotTurn: deps.snapshotTurn
+  };
+  await upsertJob(deps.dataDir, job);
+  deps.onSchedule(job);
+  return `\u5DF2\u521B\u5EFA goal job [${job.id.slice(0, 8)}]\uFF0C\u76EE\u6807\u6761\u4EF6\uFF1A${condition}`;
+}
+async function cmdUngoal(idOrPrefix, deps) {
+  const jobs = await loadJobs(deps.dataDir);
+  const target = jobs.find(
+    (j) => j.id === idOrPrefix || j.id.startsWith(idOrPrefix)
+  );
+  if (target === void 0) {
+    return `\u627E\u4E0D\u5230 job "${idOrPrefix}"\uFF0C\u8BF7\u7528 /jobs \u786E\u8BA4 id\u3002`;
+  }
+  await removeJob(deps.dataDir, target.id);
+  deps.onUnschedule(target.id);
+  return `\u5DF2\u53D6\u6D88 goal job [${target.id.slice(0, 8)}]\uFF1A${target.promptTemplate}`;
+}
+
+// src/automation/goal/rollback.ts
+function buildRollbackMessage(job) {
+  if (job.snapshotLogFile === void 0 || job.snapshotTurn === void 0) {
+    return "";
+  }
+  return `
+
+\u4E0A\u4E0B\u6587\u53EF\u80FD\u5DF2\u504F\u79BB\u76EE\u6807\uFF0C\u56DE\u6EDA\u5230\u76EE\u6807\u521B\u5EFA\u524D\u7684\u4F4D\u7F6E\uFF1A
+ecode --fork ${job.snapshotLogFile}:${job.snapshotTurn}`;
+}
+
+// src/automation/index.ts
+var AutomationManager = class {
+  constructor(config2) {
+    this.config = config2;
+    this.scheduler = new LoopScheduler({
+      onJobRun: async (job) => {
+        const entry = await executeJob(job, {
+          dataDir: config2.dataDir,
+          logDir: config2.logDir,
+          session: this.createSession()
+        });
+        if (entry) {
+          const status = entry.result === "success" ? "\u2713" : "\u2717";
+          const summary = entry.summaryText ?? entry.error ?? "";
+          config2.onJobResult?.(
+            job.id,
+            `[loop ${job.id.slice(0, 8)}] ${status} ${summary}`.trim()
+          );
+        }
+      },
+      onJobError: (job, error) => {
+        const msg = error instanceof Error ? error.message : String(error);
+        config2.onJobResult?.(job.id, `[loop ${job.id.slice(0, 8)}] \u6267\u884C\u9519\u8BEF\uFF1A${msg}`);
+      }
+    });
+  }
+  config;
+  scheduler;
+  /** 按 jobId 索引的 goal runner AbortController */
+  goalRunners = /* @__PURE__ */ new Map();
+  /**
+   * 从持久化存储加载所有 job，启动调度器并恢复 goal runner。
+   * 应在应用启动时调用一次。
+   */
+  async start() {
+    const jobs = await loadJobs(this.config.dataDir);
+    const loopJobs = jobs.filter((j) => j.kind === "loop");
+    const goalJobs = jobs.filter(
+      (j) => j.kind === "goal" && j.state === "scheduled"
+    );
+    this.scheduler.start(loopJobs);
+    for (const job of goalJobs) {
+      this.startGoalRunner(job);
+    }
+  }
+  /**
+   * 停止所有调度：清除 loop timer，中止所有 goal runner。
+   * 应在应用退出时调用。
+   */
+  stop() {
+    this.scheduler.stop();
+    for (const [, controller] of this.goalRunners) {
+      controller.abort();
+    }
+    this.goalRunners.clear();
+  }
+  // ──────────────────────────────────────────────────────────────
+  // 命令处理器（转发到 loop/goal 子模块）
+  // ──────────────────────────────────────────────────────────────
+  async cmdLoop(args) {
+    return cmdLoop(args, {
+      dataDir: this.config.dataDir,
+      onSchedule: (job) => this.scheduler.add(job),
+      onUnschedule: (id) => this.scheduler.remove(id)
+    });
+  }
+  /**
+   * 处理 /goal 命令，可选接收当前会话上下文以支持 blocked 时的自动回滚提示。
+   * sessionContext 由 App.tsx 在用户提交 /goal 时注入（logFile + turnCount）。
+   */
+  async cmdGoal(args, sessionContext) {
+    return cmdGoal(args, {
+      dataDir: this.config.dataDir,
+      snapshotLogFile: sessionContext?.logFile,
+      snapshotTurn: sessionContext?.turnCount,
+      onSchedule: (job) => this.startGoalRunner(job),
+      onUnschedule: (id) => this.stopGoalRunner(id)
+    });
+  }
+  async cmdJobs() {
+    return cmdJobs({
+      dataDir: this.config.dataDir,
+      onSchedule: () => {
+      },
+      onUnschedule: () => {
+      }
+    });
+  }
+  async cmdUnloop(id) {
+    return cmdUnloop(id, {
+      dataDir: this.config.dataDir,
+      onSchedule: () => {
+      },
+      onUnschedule: (jobId) => this.scheduler.remove(jobId)
+    });
+  }
+  async cmdUngoal(id) {
+    return cmdUngoal(id, {
+      dataDir: this.config.dataDir,
+      onSchedule: () => {
+      },
+      onUnschedule: (jobId) => this.stopGoalRunner(jobId)
+    });
+  }
+  // ──────────────────────────────────────────────────────────────
+  // 私有辅助方法
+  // ──────────────────────────────────────────────────────────────
+  /**
+   * 从 ProviderClient 构建 RuntimeSessionHandle。
+   * 将流式 chunk 拼接为完整字符串返回给调用方。
+   */
+  createSession() {
+    const { llmClient } = this.config;
+    return {
+      run: async (prompt) => {
+        let text = "";
+        const msgs = [{ role: "user", content: prompt }];
+        for await (const chunk of llmClient.stream(msgs, [], void 0)) {
+          if (chunk.text) text += chunk.text;
+        }
+        return text;
+      }
+    };
+  }
+  /** 启动 goal job 的执行协程（可被 AbortController 中断） */
+  startGoalRunner(job) {
+    this.stopGoalRunner(job.id);
+    const ac = new AbortController();
+    this.goalRunners.set(job.id, ac);
+    void this.runGoalLoop(job, ac.signal);
+  }
+  /** 中止指定 goal runner */
+  stopGoalRunner(jobId) {
+    const ac = this.goalRunners.get(jobId);
+    if (ac) {
+      ac.abort();
+      this.goalRunners.delete(jobId);
+    }
+  }
+  /**
+   * Goal job 执行循环：
+   * 1. 调用 executeJob（LLM worker 执行一轮）
+   * 2. 用 LLM 评估器判断条件是否满足
+   * 3. done → 标记 completed；blocked → 标记 error；not_done → 等待 5s 后继续
+   * 4. AbortSignal 触发时立即退出
+   */
+  async runGoalLoop(initialJob, signal) {
+    let job = initialJob;
+    while (!signal.aborted) {
+      const runtimeConfig = {
+        dataDir: this.config.dataDir,
+        logDir: this.config.logDir,
+        session: this.createSession()
+      };
+      const entry = await executeJob(job, runtimeConfig);
+      if (!entry) break;
+      if (signal.aborted) break;
+      const evaluator = createLLMEvaluator(this.createSession());
+      const evaluation = await evaluator.evaluate({
+        condition: job.condition,
+        transcript: entry.summaryText ?? entry.error ?? ""
+      });
+      const updatedJob = {
+        ...job,
+        lastEvaluation: evaluation,
+        activeTurnCount: job.activeTurnCount + 1,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (evaluation.verdict === "done") {
+        const completedJob = {
+          ...updatedJob,
+          state: "completed",
+          achievedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        await upsertJob(this.config.dataDir, completedJob);
+        this.config.onJobResult?.(
+          job.id,
+          `[goal ${job.id.slice(0, 8)}] \u76EE\u6807\u5DF2\u8FBE\u6210\uFF1A${evaluation.reason}`
+        );
+        break;
+      }
+      if (evaluation.verdict === "blocked") {
+        const errorJob = { ...updatedJob, state: "error" };
+        await upsertJob(this.config.dataDir, errorJob);
+        const rollback = buildRollbackMessage(errorJob);
+        this.config.onJobResult?.(
+          job.id,
+          `[goal ${job.id.slice(0, 8)}] \u6267\u884C\u53D7\u963B\uFF1A${evaluation.reason}${rollback}`
+        );
+        break;
+      }
+      await upsertJob(this.config.dataDir, updatedJob);
+      job = updatedJob;
+      this.config.onJobResult?.(
+        job.id,
+        `[goal ${job.id.slice(0, 8)}] \u7B2C ${job.activeTurnCount} \u8F6E\uFF1A\u5C1A\u672A\u5B8C\u6210\uFF0C\u7EE7\u7EED\u6267\u884C\u2026`
+      );
+      await new Promise((resolve5) => {
+        const timer = setTimeout(resolve5, 5e3);
+        signal.addEventListener("abort", () => {
+          clearTimeout(timer);
+          resolve5();
+        }, { once: true });
+      });
+    }
+    this.goalRunners.delete(job.id);
+  }
+};
+
+// src/sessions/metadata.ts
+import * as crypto from "crypto";
+import * as fs9 from "fs";
+import * as path7 from "path";
+function metadataPathFromLogFile(logFilePath2) {
+  const base = path7.basename(logFilePath2, ".jsonl");
+  const dir = path7.dirname(logFilePath2);
+  return path7.join(dir, `${base}-session.json`);
+}
+function createSessionMetadata(logFilePath2, model) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: crypto.randomUUID(),
+    startTime: now,
+    lastActivity: now,
+    cwd: process.cwd(),
+    model,
+    title: "",
+    turnCount: 0,
+    totalTokens: 0,
+    logFile: path7.basename(logFilePath2)
+  };
+}
+function writeSessionMetadata(logFilePath2, metadata) {
+  const metaPath = metadataPathFromLogFile(logFilePath2);
+  try {
+    fs9.writeFileSync(metaPath, JSON.stringify(metadata, null, 2) + "\n");
+  } catch (err) {
+    process.stderr.write(`[sessions] Failed to write metadata: ${err}
+`);
+  }
+}
+function readSessionMetadata(metaFilePath) {
+  try {
+    const raw = fs9.readFileSync(metaFilePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function updateSessionMetadata(logFilePath2, partial) {
+  const metaPath = metadataPathFromLogFile(logFilePath2);
+  let existing = null;
+  try {
+    const raw = fs9.readFileSync(metaPath, "utf-8");
+    existing = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  writeSessionMetadata(logFilePath2, { ...existing, ...partial });
+}
+function listSessions(logDir) {
+  try {
+    const files = fs9.readdirSync(logDir);
+    const metaFiles = files.filter((f) => f.endsWith("-session.json"));
+    const sessions = [];
+    for (const file of metaFiles) {
+      const meta = readSessionMetadata(path7.join(logDir, file));
+      if (meta) sessions.push(meta);
+    }
+    return sessions.sort(
+      (a, b) => b.lastActivity.localeCompare(a.lastActivity)
+    );
+  } catch {
+    return [];
+  }
+}
+function findSession(logDir, idOrPrefix) {
+  const sessions = listSessions(logDir);
+  return sessions.find(
+    (s) => s.id === idOrPrefix || s.id.startsWith(idOrPrefix)
+  ) ?? null;
+}
+function generateTitle(firstUserMessage) {
+  const oneLine = firstUserMessage.replace(/\n+/g, " ").trim();
+  return oneLine.length > 50 ? oneLine.slice(0, 47) + "..." : oneLine;
+}
+
 // src/ui/App.tsx
 import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+async function handleAutomationCommand(input, manager, sessionContext) {
+  if (!input.startsWith("/")) return null;
+  const spaceIdx = input.indexOf(" ");
+  const command = spaceIdx === -1 ? input : input.slice(0, spaceIdx);
+  const args = spaceIdx === -1 ? "" : input.slice(spaceIdx + 1);
+  switch (command) {
+    case "/loop":
+      return manager.cmdLoop(args);
+    // 传入会话快照：goal blocked 时可生成 ecode --fork 回滚命令
+    case "/goal":
+      return manager.cmdGoal(args, sessionContext);
+    case "/jobs":
+      return manager.cmdJobs();
+    case "/unloop":
+      return manager.cmdUnloop(args.trim());
+    case "/ungoal":
+      return manager.cmdUngoal(args.trim());
+    default:
+      return null;
+  }
+}
 function App({ config: config2, version: version2, autoMode: autoMode2 = false, registry: registry2, trustedSkillDirs: trustedSkillDirs2 = [], initialMessages: initialMessages2 = [], llmClient }) {
   const { stdout } = useStdout();
   const { stdin } = useStdin();
@@ -2161,6 +2888,17 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
   const pendingConfirmRef = useRef2(null);
   const abortControllerRef = useRef2(null);
   const llmRef = useRef2(llmClient ?? createProvider(resolveActiveProfile(config2)));
+  const automationDataDir = config2.logDir ? join10(config2.logDir, "automation") : join10(homedir2(), ".config", "ecode", "automation");
+  const automationManagerRef = useRef2(
+    new AutomationManager({
+      dataDir: automationDataDir,
+      logDir: automationDataDir,
+      llmClient: llmRef.current,
+      onJobResult: (_jobId, message) => {
+        setMessages((prev) => [...prev, { role: "assistant", content: message }]);
+      }
+    })
+  );
   const inputRef = useRef2(null);
   const [skillTools, setSkillTools] = useState3([]);
   const skillToolsRef = useRef2([]);
@@ -2170,9 +2908,15 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
   const [fileSuggestions, setFileSuggestions] = useState3([]);
   const loggerRef = useRef2(null);
   const loggedCountRef = useRef2(0);
+  const sessionMetaRef = useRef2(null);
+  const finalTokensRef = useRef2(0);
   useEffect3(() => {
     if (config2.logDir) {
-      loggerRef.current = createLogger(config2.logDir, /* @__PURE__ */ new Date());
+      const now = /* @__PURE__ */ new Date();
+      loggerRef.current = createLogger(config2.logDir, now);
+      const meta = createSessionMetadata(loggerRef.current.filePath, config2.model);
+      writeSessionMetadata(loggerRef.current.filePath, meta);
+      sessionMetaRef.current = meta;
     }
   }, []);
   useEffect3(() => {
@@ -2192,6 +2936,12 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
     }
     loggedCountRef.current = messages.length;
   }, [messages]);
+  useEffect3(() => {
+    void automationManagerRef.current.start();
+    return () => {
+      automationManagerRef.current.stop();
+    };
+  }, []);
   useEffect3(() => {
     if (!stdin || !stdout) return;
     stdout.write("\x1B[?1000h\x1B[?1006h");
@@ -2389,6 +3139,7 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
                   estimated: false,
                   limit: getContextLimit(config2.model, config2.contextLimit)
                 });
+                finalTokensRef.current = chunk.usage.totalTokens;
               }
             } else {
               const estimatedUsed = Math.floor(
@@ -2516,6 +3267,16 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
           }
         }
       }
+      if (loggerRef.current && sessionMetaRef.current) {
+        const prev = sessionMetaRef.current;
+        const updated = {
+          lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
+          totalTokens: finalTokensRef.current,
+          turnCount: prev.turnCount + 1
+        };
+        updateSessionMetadata(loggerRef.current.filePath, updated);
+        sessionMetaRef.current = { ...prev, ...updated };
+      }
       setStatus("idle");
       setToolName(void 0);
       abortControllerRef.current = null;
@@ -2539,6 +3300,25 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
       setInputHistory((prev) => [trimmed, ...prev.slice(0, 99)]);
       historyIndexRef.current = -1;
       setScrollOffset(0);
+      {
+        const automationResult = await handleAutomationCommand(
+          trimmed,
+          automationManagerRef.current,
+          // 注入会话快照：/goal blocked 时用于生成 ecode --fork 回滚命令
+          {
+            logFile: loggerRef.current?.filePath,
+            turnCount: sessionMetaRef.current?.turnCount
+          }
+        );
+        if (automationResult !== null) {
+          setMessages((prev) => [
+            ...prev,
+            { role: "user", content: trimmed },
+            { role: "assistant", content: automationResult }
+          ]);
+          return;
+        }
+      }
       if (registry2) {
         const skillResult = handleSkillInput(trimmed, registry2);
         if (skillResult.type === "error") {
@@ -2582,6 +3362,11 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
       const userMsg = { role: "user", content };
       const nextMessages = [...messages, userMsg];
       setMessages(nextMessages);
+      if (loggerRef.current && sessionMetaRef.current && !sessionMetaRef.current.title) {
+        const title = generateTitle(content);
+        updateSessionMetadata(loggerRef.current.filePath, { title });
+        sessionMetaRef.current = { ...sessionMetaRef.current, title };
+      }
       runLlmLoop(nextMessages).catch((err) => {
         setStatus("idle");
         setToolName(void 0);
@@ -2766,6 +3551,53 @@ function readStdin() {
   });
 }
 
+// src/sessions/command.ts
+import * as path8 from "path";
+function cmdSessionsList(logDir) {
+  const sessions = listSessions(logDir);
+  if (sessions.length === 0) return "(no sessions found)";
+  const lines = sessions.map((s) => {
+    const id = s.id.slice(0, 8);
+    const date = new Date(s.lastActivity).toLocaleString();
+    const title = s.title || "(no title)";
+    const tokens = s.totalTokens.toLocaleString();
+    return `${id}  ${date}  ${tokens}t  ${title}`;
+  });
+  return `Sessions (${sessions.length}):
+` + lines.join("\n");
+}
+function cmdSessionsInspect(logDir, idOrPrefix) {
+  const session = findSession(logDir, idOrPrefix);
+  if (!session) return `Session not found: ${idOrPrefix}`;
+  return formatInspect(session, logDir);
+}
+function cmdSessionsReplay(logDir, idOrPrefix) {
+  const session = findSession(logDir, idOrPrefix);
+  if (!session) return `Session not found: ${idOrPrefix}`;
+  const logPath = path8.join(logDir, session.logFile);
+  return `ecode --replay ${logPath}`;
+}
+function cmdSessionsFork(logDir, idOrPrefix, turn) {
+  const session = findSession(logDir, idOrPrefix);
+  if (!session) return `Session not found: ${idOrPrefix}`;
+  const logPath = path8.join(logDir, session.logFile);
+  const turnStr = turn !== void 0 ? turn : session.turnCount;
+  return `ecode --fork ${logPath}:${turnStr}`;
+}
+function formatInspect(session, logDir) {
+  return [
+    `id:           ${session.id}`,
+    `title:        ${session.title || "(no title)"}`,
+    `model:        ${session.model}`,
+    `cwd:          ${session.cwd}`,
+    `started:      ${new Date(session.startTime).toLocaleString()}`,
+    `last active:  ${new Date(session.lastActivity).toLocaleString()}`,
+    `turns:        ${session.turnCount}`,
+    `tokens:       ${session.totalTokens.toLocaleString()}`,
+    `log file:     ${path8.join(logDir, session.logFile)}`
+  ].join("\n");
+}
+
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
@@ -2819,6 +3651,46 @@ for (let i = 0; i < rawArgs.length; i++) {
 }
 var config = loadConfig();
 var finalConfig = cliLogDir ? { ...config, logDir: cliLogDir } : config;
+if (rawArgs[0] === "sessions") {
+  const sub = rawArgs[1];
+  const logDir = finalConfig.logDir;
+  if (!logDir) {
+    console.error(
+      "Error: no log directory configured.\nSet ECODE_LOG_DIR or logDir in ~/.ecode/config.json"
+    );
+    process.exit(1);
+  }
+  let output;
+  if (sub === "list") {
+    output = cmdSessionsList(logDir);
+  } else if (sub === "inspect") {
+    const id = rawArgs[2];
+    if (!id) {
+      console.error("Usage: ecode sessions inspect <id>");
+      process.exit(1);
+    }
+    output = cmdSessionsInspect(logDir, id);
+  } else if (sub === "replay") {
+    const id = rawArgs[2];
+    if (!id) {
+      console.error("Usage: ecode sessions replay <id>");
+      process.exit(1);
+    }
+    output = cmdSessionsReplay(logDir, id);
+  } else if (sub === "fork") {
+    const id = rawArgs[2];
+    if (!id) {
+      console.error("Usage: ecode sessions fork <id> [turn]");
+      process.exit(1);
+    }
+    const turnArg = rawArgs[3] ? parseInt(rawArgs[3], 10) : void 0;
+    output = cmdSessionsFork(logDir, id, turnArg);
+  } else {
+    output = "Usage: ecode sessions <list|inspect|replay|fork> [args...]\n\n  list                     \u5217\u51FA\u6240\u6709\u5386\u53F2\u4F1A\u8BDD\n  inspect <id>             \u663E\u793A\u4F1A\u8BDD\u8BE6\u60C5\n  replay  <id>             \u8F93\u51FA\u7528\u4E8E\u56DE\u653E\u7684\u547D\u4EE4\n  fork    <id> [turn]      \u8F93\u51FA\u7528\u4E8E\u5206\u53C9\u5230\u6307\u5B9A\u8F6E\u6B21\u7684\u547D\u4EE4";
+  }
+  console.log(output);
+  process.exit(0);
+}
 if (!finalConfig.apiKey) {
   console.error(
     "Error: no API key configured.\nSet ECODE_API_KEY or add apiKey to ~/.ecode/config.json"
@@ -2828,7 +3700,7 @@ if (!finalConfig.apiKey) {
 var initialMessages = [];
 if (replayFile) {
   try {
-    const raw = readFileSync2(replayFile, "utf-8");
+    const raw = readFileSync3(replayFile, "utf-8");
     initialMessages = parseReplayLog(raw);
   } catch (err) {
     console.error(`Error reading replay file: ${err}`);
@@ -2836,14 +3708,14 @@ if (replayFile) {
   }
 } else if (forkSpec) {
   try {
-    const raw = readFileSync2(forkSpec.file, "utf-8");
+    const raw = readFileSync3(forkSpec.file, "utf-8");
     initialMessages = truncateToTurn(parseReplayLog(raw), forkSpec.turn);
   } catch (err) {
     console.error(`Error reading fork file: ${err}`);
     process.exit(1);
   }
 }
-var __dirname = dirname6(fileURLToPath(import.meta.url));
+var __dirname = dirname7(fileURLToPath(import.meta.url));
 var builtinSkillsDir = resolve4(__dirname, "../skills");
 var userSkillsDir = resolve4(process.env.HOME ?? "~", ".ecode/skills");
 var projectSkillsDir = resolve4(process.cwd(), ".ecode/skills");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhongqian97-code/ecode",
-  "version": "0.3.12",
+  "version": "0.5.1",
   "description": "A minimal Claude Code clone with REPL interface and bash tool calling",
   "type": "module",
   "author": "zhongqian97-code",