@zhongqian97-code/ecode 0.3.12 → 0.4.0

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:

package/dist/index.js

@@ -2126,8 +2126,635 @@ function parseMouseScroll(data) {
   return null;
 }
 
+// src/ui/App.tsx
+import { homedir as homedir2 } from "os";
+import { join as join9 } 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
+  };
+  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/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)
+    });
+  }
+  async cmdGoal(args) {
+    return cmdGoal(args, {
+      dataDir: this.config.dataDir,
+      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);
+        this.config.onJobResult?.(
+          job.id,
+          `[goal ${job.id.slice(0, 8)}] \u6267\u884C\u53D7\u963B\uFF1A${evaluation.reason}`
+        );
+        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/ui/App.tsx
 import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+async function handleAutomationCommand(input, manager) {
+  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);
+    case "/goal":
+      return manager.cmdGoal(args);
+    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 +2788,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 ? join9(config2.logDir, "automation") : join9(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([]);
@@ -2192,6 +2830,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");
@@ -2539,6 +3183,20 @@ 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
+        );
+        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") {

package/package.json

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