@codizelabs/agent-rewake 0.4.0 → 0.5.0

package/README.md

@@ -37,6 +37,8 @@ Coding agents stop at their usage limit: Claude's 5-hour session limit, Codex's
 - **Automatic, if you want.** Choose *from now on* when Rewake asks (Claude Code), turn on auto-resume in Zed's **Rewake** menu, or run `agent-rewake continue --always` (Copilot CLI, Gemini CLI, Grok Build, Qwen Code, OpenCode, Antigravity CLI), and Rewake resumes without asking. It asks first when a limit resets more than a day away, never resumes credit or billing limits (and says so), and never approves permission prompts for you.
 - **Sends messages later.** `/rewake in 1h Run the tests` schedules a message into the session (Zed and Claude Code; in Zed also on a repeat, such as every weekday at 9).
 - **Keeps the computer awake, if it can.** On macOS, and on Linux (with systemd) and Windows, while a resume is due within six hours, Rewake stops the computer from idling to sleep (while plugged in, by default). Only macOS has been tried by hand. Closing the lid still puts it to sleep. `agent-rewake doctor` tells you if your computer's own sleep settings would let it sleep, and [which settings to change](https://codizelabs.github.io/agent-rewake/docs/#keep-your-computer-awake).
+- **Warns you before a usage limit (Claude Code).** The plugin tells you when a usage window passes 80% and 95%, and when your pace over the last hour would reach the limit within about 45 minutes (as a range, "in about 20 to 40 minutes"). It uses only the usage figures Claude Code already gives it: no network, no sign-in. It only tells you; at 80% it mentions `/compact` (which uses some quota itself), at 95% it says it is a good moment to wrap up. It never types or compacts for you. Turn it off with `agent-rewake settings usage-warnings off`. Not built for Codex and the other agents.
+- **Tells you when the project changed while it waited.** Outside Zed, if the session's folder is a git folder and its latest commit or tracked files differ by the time Rewake sends, it tells you, and sends the message as it was. You can instead have it add one fixed line asking the agent to re-read files (`agent-rewake settings workspace-changed note`), or send nothing and ask you first (`hold`). It reads only the commit id and the names-and-status summary from `git status --porcelain --untracked-files=no`, never file contents, and only on your computer.
 - **Same agent, same session.** No new agent to pick: Rewake works inside or in front of the agents you already use, so your sessions and threads keep going where they stopped.
 
 ## Where you work
@@ -88,7 +90,7 @@ npx @codizelabs/agent-rewake doctor
 
 ### Updating
 
-From any version: run `npx @codizelabs/agent-rewake@latest install`. Previews use the new version from their next session; in Zed, quit Zed completely and open it again. Your sessions, scheduled messages and settings stay. Details, and any version-specific steps (none so far), are in the [docs](https://codizelabs.github.io/agent-rewake/docs/#update). To see which version you run: `agent-rewake --version` (in Zed also the **Rewake** menu).
+From any version: run `npx @codizelabs/agent-rewake@latest install`. Previews use the new version from their next session; in Zed, choose **Reload Agent** in the Agent Panel's menu in each open thread (Zed 1.18 or newer), or quit Zed completely and open it again. Your sessions, scheduled messages and settings stay. Details, and any version-specific steps (none so far), are in the [docs](https://codizelabs.github.io/agent-rewake/docs/#update). To see which version you run: `agent-rewake --version` (in Zed also the **Rewake** menu).
 
 ### Requirements
 
@@ -120,6 +122,7 @@ In Zed, the **Rewake** menu under the message box does everything; elsewhere, ty
 | See or change messages | **Rewake → Schedules**, **Change a scheduled message…** | `/rewake list` and `/rewake cancel` (Claude Code, Gemini CLI, Grok Build, Qwen Code, Cursor; in Codex without the slash). `/rewake cancel N` deletes one message: Claude Code only |
 | See what's planned | The Zed task **Agent Rewake: schedules** | `/rewake list` in the session; `agent-rewake schedules` lists every one, marking the resumes outside Zed; `agent-rewake doctor` shows the next planned resume of a closed session |
 | Cancel a planned resume | **Rewake → Change a scheduled message…**, or the schedules page | `/rewake cancel` in the session where it's typed, or `agent-rewake continue --cancel` to pick one or all; `agent-rewake continue --cancel <id>` cancels one by the id in square brackets in `agent-rewake schedules` |
+| Resume now, without waiting for the reset | **Rewake → Change a scheduled message…** | `agent-rewake continue --now` picks a planned resume outside Zed and asks first; `agent-rewake continue --now <id>` names one (`--yes` without a terminal). It makes the same checks as at the reset; if the limit is still on, the session is open or changed, you typed after the limit, the agent continued, or the message can't reach the agent (signed out, session deleted or archived, folder gone), nothing is sent and the resume stays planned for its time; Ctrl+C during a run stops it and cancels the resume |
 | Change settings | **Rewake → Settings…** | `agent-rewake settings` lists them with what each does; `agent-rewake settings change` lets you pick one, or `agent-rewake settings <name> <value>` changes it (for example `agent-rewake settings clock 24h`) |
 
 **One command everywhere:** `/rewake` is the same in Zed, Claude Code, Gemini CLI, Grok Build, Qwen Code and Cursor's own agent (in Codex, type `rewake` without the slash). At a usage limit it continues after the reset; `/rewake <time>` continues then, `/rewake cancel` cancels it, and `/rewake help` lists what else works where you are. Rewake answers it itself, without using the model. `npx`/`agent-rewake` on the command line is only for installing, uninstalling and the two agents with no typed command (GitHub Copilot CLI, Antigravity CLI).
@@ -135,7 +138,7 @@ In Zed, Rewake works the same way in front of every external agent: **Claude Age
 The whole picture, with what Rewake never does and how to undo it, is on the [privacy and security page](https://codizelabs.github.io/agent-rewake/docs/privacy-and-security/). In short:
 
 - Runs locally. Rewake never sees your credentials: sign-in goes through each agent's own flow. Besides fetching an agent's own program (a download, or `npm install`) when Zed hasn't already done it, its only network use is error reports, which are off unless you turn them on (`agent-rewake errors on`; see the docs' [Error reports](https://codizelabs.github.io/agent-rewake/docs/#error-reports)).
-- Sends only what you scheduled, approved, or turned on.
+- Sends only what you scheduled, approved, or turned on. (One fixed line, saying the project changed while it waited, is added to a resume only if you choose `note`.)
 - Stores scheduled messages and per-thread settings in a private folder on your machine; logs hold metadata only (events, codes and program names), never message text.
 - Keeps your message off the command line, with exceptions. When Rewake continues a closed Copilot CLI, Gemini CLI, Qwen Code or OpenCode session, it hands the message to the agent on its standard input; for Grok Build, in a file only you can read. Three cases put it on a command line, where another program on your computer can read it from the process list for as long as the command runs: **Codex** (`codex queue --message <text>`), **Antigravity CLI** (`-p <text>`), and **Gemini CLI** or **Qwen Code** when you've turned its sandbox on (they then start themselves again with the text as an argument; for Qwen Code that is read from its source, not tried). Claude Code, Cursor and Zed don't use a command line for it.
 
@@ -149,7 +152,7 @@ This takes Rewake out of every place it's set up in, after showing every change
 
 ## Status
 
-Version 0.4. Rewake's automated tests run on macOS, Linux and Windows with Node.js 22 and 24, and the author uses it daily in Zed. The previews outside Zed are new: the docs say [what's been tried for each](https://codizelabs.github.io/agent-rewake/docs/#outside-zed-previews), and what hasn't. What changed in each release is in the [changelog](https://codizelabs.github.io/agent-rewake/changelog/). Feedback and bug reports are very welcome: [open an issue](https://github.com/codizelabs/agent-rewake/issues/new/choose). If Rewake missed a usage limit, [say how](https://codizelabs.github.io/agent-rewake/docs/#report-a-limit-rewake-missed).
+Version 0.5. Rewake's automated tests run on macOS, Linux and Windows with Node.js 22 and 24, and the author uses it daily in Zed. The previews outside Zed are new: the docs say [what's been tried for each](https://codizelabs.github.io/agent-rewake/docs/#outside-zed-previews), and what hasn't. What changed in each release is in the [changelog](https://codizelabs.github.io/agent-rewake/changelog/). Feedback and bug reports are very welcome: [open an issue](https://github.com/codizelabs/agent-rewake/issues/new/choose). If Rewake missed a usage limit, [say how](https://codizelabs.github.io/agent-rewake/docs/#report-a-limit-rewake-missed).
 
 ## Contributing
 

package/dist/agent-rewake.js

@@ -2366,6 +2366,68 @@ var init_options_bridge = __esm({
   }
 });
 
+// src/util/workspace.ts
+import { execFileSync } from "node:child_process";
+import { createHash as createHash2 } from "node:crypto";
+function gitEnv() {
+  const { GIT_DIR: _d, GIT_WORK_TREE: _w, GIT_INDEX_FILE: _i, ...rest } = process.env;
+  return rest;
+}
+function git(cwd, args, deadline) {
+  const left = deadline - Date.now();
+  if (left <= 0) return void 0;
+  try {
+    return execFileSync(
+      "git",
+      ["--no-optional-locks", "-c", "core.fsmonitor=false", "-C", cwd, ...args],
+      {
+        encoding: "utf8",
+        timeout: left,
+        maxBuffer: MAX_OUTPUT_BYTES,
+        stdio: ["ignore", "pipe", "ignore"],
+        windowsHide: true,
+        env: gitEnv()
+      }
+    );
+  } catch {
+    return void 0;
+  }
+}
+function fingerprintWorkspace(cwd, budgetMs = FIRE_BUDGET_MS) {
+  if (!cwd) return void 0;
+  const deadline = Date.now() + budgetMs;
+  const commit = git(cwd, ["rev-parse", "HEAD"], deadline)?.trim();
+  if (!commit || !/^[0-9a-f]{40,64}$/.test(commit)) return void 0;
+  const status = git(cwd, ["status", "--porcelain", "--untracked-files=no"], deadline);
+  if (status === void 0) return void 0;
+  const lines = status.split("\n").filter(Boolean).sort();
+  return {
+    commit,
+    hash: createHash2("sha256").update(lines.join("\n")).digest("hex"),
+    dirty: lines.length > 0
+  };
+}
+function workspaceChange(before, after) {
+  const commit = before.commit !== after.commit;
+  const changes = before.hash !== after.hash;
+  return commit || changes ? { commit, changes } : void 0;
+}
+function validFingerprint(w) {
+  if (typeof w !== "object" || w === null) return false;
+  const x = w;
+  return typeof x.commit === "string" && x.commit.length <= 64 && typeof x.hash === "string" && x.hash.length <= 64 && typeof x.dirty === "boolean";
+}
+var ARM_BUDGET_MS, FIRE_BUDGET_MS, MAX_OUTPUT_BYTES, WORKSPACE_NOTE;
+var init_workspace = __esm({
+  "src/util/workspace.ts"() {
+    "use strict";
+    ARM_BUDGET_MS = 1e3;
+    FIRE_BUDGET_MS = 2e3;
+    MAX_OUTPUT_BYTES = 16 * 1024 * 1024;
+    WORKSPACE_NOTE = "Note from Rewake: the project changed while this session waited for the usage limit to reset. Re-read any files before editing them.";
+  }
+});
+
 // src/core/store.ts
 import { randomUUID } from "node:crypto";
 import {
@@ -2399,7 +2461,7 @@ function validFollowUps(t) {
 function validateSchedule(value) {
   if (value === null || typeof value !== "object") return void 0;
   const s = value;
-  const ok = s.schemaVersion === 1 && typeof s.scheduleId === "string" && /^[0-9a-f-]{36}$/.test(s.scheduleId) && typeof s.sessionId === "string" && s.sessionId.length > 0 && typeof s.cwd === "string" && (s.kind === "user" || s.kind === "limit_resume" || s.kind === "auto_limit_resume") && typeof s.text === "string" && s.text.trim().length > 0 && Buffer.byteLength(s.text) <= MAX_TEXT_BYTES && typeof s.dueAt === "number" && Number.isFinite(s.dueAt) && typeof s.status === "string" && STATUSES.has(s.status) && Array.isArray(s.attempts) && typeof s.createdAt === "number" && typeof s.updatedAt === "number" && (s.repeat === void 0 || validRepeat(s.repeat)) && (s.followUps === void 0 || validFollowUps(s.followUps)) && (s.host === void 0 || typeof s.host === "string" && KNOWN_HOSTS.has(s.host)) && (s.sessionRef === void 0 || validSessionRef(s.sessionRef)) && (s.rearms === void 0 || typeof s.rearms === "number" && Number.isInteger(s.rearms) && s.rearms >= 0) && (s.earlyRearms === void 0 || typeof s.earlyRearms === "number" && Number.isInteger(s.earlyRearms) && s.earlyRearms >= 0);
+  const ok = s.schemaVersion === 1 && typeof s.scheduleId === "string" && /^[0-9a-f-]{36}$/.test(s.scheduleId) && typeof s.sessionId === "string" && s.sessionId.length > 0 && typeof s.cwd === "string" && (s.kind === "user" || s.kind === "limit_resume" || s.kind === "auto_limit_resume") && typeof s.text === "string" && s.text.trim().length > 0 && Buffer.byteLength(s.text) <= MAX_TEXT_BYTES && typeof s.dueAt === "number" && Number.isFinite(s.dueAt) && typeof s.status === "string" && STATUSES.has(s.status) && Array.isArray(s.attempts) && typeof s.createdAt === "number" && typeof s.updatedAt === "number" && (s.repeat === void 0 || validRepeat(s.repeat)) && (s.followUps === void 0 || validFollowUps(s.followUps)) && (s.host === void 0 || typeof s.host === "string" && KNOWN_HOSTS.has(s.host)) && (s.sessionRef === void 0 || validSessionRef(s.sessionRef)) && (s.rearms === void 0 || typeof s.rearms === "number" && Number.isInteger(s.rearms) && s.rearms >= 0) && (s.earlyRearms === void 0 || typeof s.earlyRearms === "number" && Number.isInteger(s.earlyRearms) && s.earlyRearms >= 0) && (s.workspace === void 0 || validFingerprint(s.workspace));
   return ok ? value : void 0;
 }
 function writeFileAtomic(dir, name, data) {
@@ -2420,6 +2482,7 @@ var init_store = __esm({
     "use strict";
     init_fs();
     init_paths();
+    init_workspace();
     init_cron();
     init_lock();
     PAUSE = new Int32Array(new SharedArrayBuffer(4));
@@ -2719,6 +2782,8 @@ function loadSettings(stateDir2) {
     const autoWhenPromptsSkipped = raw.autoWhenPromptsSkipped !== false;
     const keepAwake = KEEP_AWAKE_VALUES.find((v) => v === raw.keepAwake) ?? DEFAULT_SETTINGS.keepAwake;
     const errorReports = raw.errorReports === "on" ? "on" : DEFAULT_SETTINGS.errorReports;
+    const workspaceChanged = WORKSPACE_CHANGED_VALUES.find((v) => v === raw.workspaceChanged) ?? DEFAULT_SETTINGS.workspaceChanged;
+    const usageWarnings = raw.usageWarnings === "off" ? "off" : DEFAULT_SETTINGS.usageWarnings;
     const errorReportsAsked = raw.errorReportsAsked === true;
     return {
       clock: clock2,
@@ -2726,6 +2791,8 @@ function loadSettings(stateDir2) {
       autoWhenPromptsSkipped,
       keepAwake,
       errorReports,
+      workspaceChanged,
+      usageWarnings,
       ...resumePrompt && { resumePrompt },
       ...errorReportsAsked && { errorReportsAsked }
     };
@@ -2746,7 +2813,7 @@ function applySettings(stateDir2) {
   setClock(s.clock);
   return s;
 }
-var CLOCKS, NEW_THREADS_VALUES, KEEP_AWAKE_VALUES, MAX_RESUME_PROMPT, KEEP_AWAKE_SAVED, DEFAULT_SETTINGS;
+var CLOCKS, NEW_THREADS_VALUES, KEEP_AWAKE_VALUES, WORKSPACE_CHANGED_VALUES, USAGE_WARNINGS_VALUES, MAX_RESUME_PROMPT, KEEP_AWAKE_SAVED, DEFAULT_SETTINGS;
 var init_settings = __esm({
   "src/core/settings.ts"() {
     "use strict";
@@ -2756,6 +2823,13 @@ var init_settings = __esm({
     CLOCKS = ["12h", "24h"];
     NEW_THREADS_VALUES = ["ask", "on", "off"];
     KEEP_AWAKE_VALUES = ["plugged-in", "always", "never"];
+    WORKSPACE_CHANGED_VALUES = [
+      "tell",
+      "note",
+      "hold",
+      "off"
+    ];
+    USAGE_WARNINGS_VALUES = ["on", "off"];
     MAX_RESUME_PROMPT = 16384;
     KEEP_AWAKE_SAVED = {
       "plugged-in": "Rewake keeps this computer awake for resumes and scheduled messages while it's plugged in.",
@@ -2767,13 +2841,15 @@ var init_settings = __esm({
       newThreads: "ask",
       autoWhenPromptsSkipped: true,
       keepAwake: "plugged-in",
-      errorReports: "off"
+      errorReports: "off",
+      workspaceChanged: "tell",
+      usageWarnings: "on"
     };
   }
 });
 
 // src/core/threads.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { readdirSync as readdirSync4, readFileSync as readFileSync7, rmSync as rmSync5 } from "node:fs";
 import { join as join8 } from "node:path";
 var DEFAULT_RESUME_PROMPT, ThreadStore;
@@ -2789,7 +2865,7 @@ var init_threads = __esm({
         this.dir = join8(stateDir2, "threads");
       }
       file(sessionId) {
-        return `${createHash2("sha256").update(sessionId).digest("hex").slice(0, 32)}.json`;
+        return `${createHash3("sha256").update(sessionId).digest("hex").slice(0, 32)}.json`;
       }
       get(sessionId) {
         try {
@@ -4479,20 +4555,20 @@ function killTree(child, p = osPlatform2(), signal = "SIGTERM", run3 = taskkill)
   }
   child.kill(signal);
 }
-function killPidTree(pid, p = osPlatform2(), run3 = taskkill) {
+function killPidTree(pid, p = osPlatform2(), run3 = taskkill, signal = "SIGTERM") {
   killTree(
     {
       pid,
-      kill: (signal) => {
+      kill: (signal2) => {
         try {
-          return process.kill(pid, signal);
+          return process.kill(pid, signal2);
         } catch {
           return false;
         }
       }
     },
     p,
-    "SIGTERM",
+    signal,
     run3
   );
 }
@@ -4892,7 +4968,7 @@ var init_version = __esm({
         return {};
       }
     })();
-    VERSION2 = pkg.version ?? (true ? "0.4.0" : "0.0.0");
+    VERSION2 = pkg.version ?? (true ? "0.5.0" : "0.0.0");
     PACKAGE_NAME = pkg.name ?? "@codizelabs/agent-rewake";
     FROM_SOURCE = false;
   }
@@ -5498,6 +5574,11 @@ function armedText(host, cwd, at, now) {
   const typing = host.keepOpen ? `Typing in the ${host.noun ?? "session"} before then cancels this continue.` : `Reopening that ${host.noun ?? "session"} and typing in it before then cancels this resume.`;
   return `Rewake will continue ${placeOf(host, cwd)} ${formatAt(at, now)}. Keep this computer on and awake until then.${keep} ${typing} To cancel all planned resumes: ${rewake("continue --cancel")}`;
 }
+function withWorkspace(store, s, now) {
+  const workspace = fingerprintWorkspace(s.cwd, ARM_BUDGET_MS);
+  if (!workspace) return s;
+  return store.update(s.scheduleId, (x) => ({ ...x, workspace }), now) ?? s;
+}
 function armClosed(host, r, at, d) {
   const store = new ScheduleStore(d.stateDir);
   const settings = loadSettings(d.stateDir);
@@ -5517,7 +5598,7 @@ function armClosed(host, r, at, d) {
   };
   store.put(resume);
   d.arm(resume.scheduleId, at + (host.fallbackDelayMs ?? 0));
-  return resume;
+  return withWorkspace(store, resume, d.now);
 }
 function onSessionStart(host, sessionId, cwd, d, program) {
   if (d.env[FIRE_ENV]) return;
@@ -5692,6 +5773,7 @@ var init_closed = __esm({
     init_command2();
     init_proc();
     init_secrets();
+    init_workspace();
     init_sessions();
     FIRE_ENV = "AGENT_REWAKE_FIRE";
     COMMON_VARS = ["XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_STATE_HOME", "XDG_CACHE_HOME"];
@@ -8205,7 +8287,7 @@ var init_install6 = __esm({
 
 // src/wrap.ts
 import { spawnSync as spawnSync8 } from "node:child_process";
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import {
   chmodSync as chmodSync2,
   existsSync as existsSync14,
@@ -8359,7 +8441,7 @@ function ensureNpxAgent(id, npx, stateDir2, env, logFile) {
   );
 }
 function zedBinaryDir(id, version, target, env) {
-  const sha = (s) => createHash3("sha256").update(s).digest("hex").slice(0, 16);
+  const sha = (s) => createHash4("sha256").update(s).digest("hex").slice(0, 16);
   const archiveKey = target.sha256 ? `${target.archive}\0sha256:${target.sha256.toLowerCase()}` : target.archive;
   return join24(
     zedDataDir(env),
@@ -8430,7 +8512,7 @@ async function downloadBinaryAgent(id, version, target, stateDir2, fetchImpl = f
     if (!res.ok) throw new Error(`download failed (HTTP ${res.status})`);
     const bytes = Buffer.from(await res.arrayBuffer());
     if (target.sha256) {
-      const got = createHash3("sha256").update(bytes).digest("hex");
+      const got = createHash4("sha256").update(bytes).digest("hex");
       if (got !== target.sha256.toLowerCase())
         throw new Error("the download doesn't match the registry's checksum");
     }
@@ -9803,6 +9885,9 @@ function quitZed(p = platform3()) {
   if (p === "win32") return "close every Zed window so Zed exits";
   return "quit Zed completely (Ctrl+Q)";
 }
+function reloadAgent(p = platform3()) {
+  return `choose "Reload Agent" in the Agent Panel's menu in each open thread (Zed 1.18 or newer), or ${quitZed(p)} and open it again`;
+}
 function nextSteps(reachShown = false) {
   return [
     "",
@@ -10011,7 +10096,8 @@ function explainResume(r, now, locale) {
     lines.push(
       `  When: ${when2}`,
       `  What Rewake will do: send your message "${oneLine(r.text)}" into the ${r.noun} once.`,
-      `  Nothing is sent now: this view only reads. ${r.cancel}`
+      `  Nothing is sent now: this view only reads. ${r.cancel}`,
+      ...r.now ? [`  ${r.now}`] : []
     );
     return lines;
   }
@@ -10029,6 +10115,10 @@ function explainResume(r, now, locale) {
     lines.push(
       "  Its time has already passed by too long, so Rewake won't send it by itself. It will tell you."
     );
+  if (r.workspaceChanged === "tell" || r.workspaceChanged === "note")
+    lines.push(
+      `  Before sending, Rewake checks whether the project's latest git commit or tracked files differ from when this was planned (only the commit id and a summary of file names and status, never contents). If they do, ${r.workspaceChanged === "note" ? "it adds a line to the message asking the agent to re-read files before editing, and tells you" : "it tells you and sends the message as it is"}.`
+    );
   lines.push("  What could stop it:");
   lines.push(
     `  - You type in the ${r.noun} before then: Rewake sends nothing.`,
@@ -10038,12 +10128,17 @@ function explainResume(r, now, locale) {
     lines.push(
       `  - The ${r.noun} is open in a window or terminal then: Rewake sends nothing and tells you.`
     );
+  if (r.workspaceChanged === "hold")
+    lines.push(
+      "  - The project's latest git commit or tracked files differ from when this was planned (Rewake reads only the commit id and a summary of file names and status, never contents): Rewake sends nothing and tells you."
+    );
   lines.push(
     "  - The agent is still at its usage limit: Rewake waits for the new reset and tries again, or tells you if it can't.",
     "  - The computer is off or asleep then: Rewake sends nothing if it runs much later, and tells you.",
     "  - A credit or billing limit: Rewake never resumes it, because waiting doesn't fix it.",
     `  Nothing is sent now: this view only reads. ${r.cancel}`
   );
+  if (r.now) lines.push(`  ${r.now}`);
   return lines;
 }
 var PENDING, oneLine;
@@ -10268,6 +10363,7 @@ function explainSchedule(stateDir2, idPrefix, now, hostOf, locale) {
   const folder = s.cwd ? basename7(s.cwd) : "";
   const title = new ThreadStore(stateDir2).get(s.sessionId)?.title;
   const where2 = host ? folder ? `${host.name} in the "${folder}" folder` : host.name : title ? `The Zed thread "${title}"` : `The Zed thread ${s.sessionId.slice(0, 8)}`;
+  const workspaceSetting = loadSettings(stateDir2).workspaceChanged;
   const lines = explainResume(
     {
       dueAt: s.dueAt,
@@ -10279,7 +10375,11 @@ function explainSchedule(stateDir2, idPrefix, now, hostOf, locale) {
       noun: host?.noun ?? "thread",
       outsideZed: host !== void 0,
       ...host === void 0 && { lateMs: ZED_LATE_MS },
-      cancel: host ? `To cancel it: ${rewake(`continue --cancel ${s.scheduleId.slice(0, 8)}`)}` : `To cancel it, use the schedules page: ${rewake("ui")}`
+      ...host !== void 0 && s.workspace && workspaceSetting !== "off" && { workspaceChanged: workspaceSetting },
+      cancel: host ? `To cancel it: ${rewake(`continue --cancel ${s.scheduleId.slice(0, 8)}`)}` : `To cancel it, use the schedules page: ${rewake("ui")}`,
+      ...host && {
+        now: `To continue it now instead of waiting for the reset: ${rewake(`continue --now ${s.scheduleId.slice(0, 8)}`)}`
+      }
     },
     now,
     locale
@@ -10321,6 +10421,7 @@ var init_overview = __esm({
   "src/ui/overview.ts"() {
     "use strict";
     init_explain();
+    init_settings();
     init_store();
     init_threads();
     init_time();
@@ -13681,6 +13782,7 @@ ${pending.map((s, i) => `  ${i + 1}. ${about(o, s)}  [${s.scheduleId.slice(0, 8)
     for (const s of chosen3) await cancel(o, store, s);
     return 0;
   }
+  if (o.mode === "now") return runNow(o);
   const list2 = waiting(o);
   if (list2.length === 0) {
     o.out("Nothing to continue: no closed session is stopped at a usage limit.\n");
@@ -13835,7 +13937,7 @@ function about(o, s) {
   const host = hostFor(o, s.host);
   return `${host ? `${placeOf(host, s.cwd)} ` : s.host === void 0 ? "Zed thread " : ""}${formatAt(s.dueAt, o.deps.now)}`;
 }
-async function cancelOne(o, store, id) {
+function findOne(o, store, id) {
   const wanted = id.trim().toLowerCase();
   const found = wanted ? store.list().filter((s2) => s2.scheduleId.toLowerCase().startsWith(wanted)) : [];
   const fail2 = (text2) => {
@@ -13857,6 +13959,11 @@ ${found.map((s2) => `  ${s2.scheduleId.slice(0, 8)}  ${about(o, s2)}`).join("\n"
     return fail2(
       `That's a message in a Zed thread: change or delete it on the schedules page (${rewake("ui")}), or in the thread's Rewake menu.`
     );
+  return s;
+}
+async function cancelOne(o, store, id) {
+  const s = findOne(o, store, id);
+  if (typeof s === "number") return s;
   if (TERMINAL_STATUSES.has(s.status)) {
     const host = hostFor(o, s.host);
     o.out(
@@ -13867,6 +13974,150 @@ ${found.map((s2) => `  ${s2.scheduleId.slice(0, 8)}  ${about(o, s2)}`).join("\n"
   }
   return await cancel(o, store, s) ? 0 : 1;
 }
+async function runNow(o) {
+  const now = o.deps.now;
+  const store = new ScheduleStore(o.deps.stateDir);
+  if (!o.interactive && (o.nowId === void 0 || o.yes !== true)) {
+    (o.err ?? o.out)(
+      `agent-rewake: There is no terminal to ask in, so nothing was sent. Give the id and --yes: ${rewake("continue --now <id> --yes")}. The ids are in ${rewake("schedules")}, in square brackets.
+`
+    );
+    return 1;
+  }
+  let s;
+  if (o.nowId !== void 0) {
+    const found = findOne(o, store, o.nowId);
+    if (typeof found === "number") return found;
+    s = found;
+  } else {
+    const windowOf = (x) => o.hosts.find((h) => h.id === x.host && h.maxWaitAfterLimitMs !== void 0);
+    const waitingHere = store.list().filter((x) => x.host !== void 0 && x.host !== "acp" && WAITING.has(x.status));
+    const pending = waitingHere.filter((x) => !windowOf(x));
+    if (pending.length === 0) {
+      const blocked = waitingHere.map(windowOf).find((h) => h !== void 0);
+      o.out(
+        blocked ? `Nothing here can be continued now: ${windowReason(blocked)}.
+` : "Nothing to resume now: Rewake isn't set to continue any session.\n"
+      );
+      return 0;
+    }
+    s = pending[0];
+    if (pending.length > 1) {
+      const placeIn = (x) => {
+        const h = hostFor(o, x.host);
+        return h ? placeOf(h, x.cwd) : "";
+      };
+      const twin = (x) => pending.filter((y) => placeIn(y) === placeIn(x)).length > 1;
+      o.out(
+        `Planned resumes:
+${pending.map((x, i) => `  ${i + 1}. ${about(o, x)}${twin(x) ? ` (${printable(x.cwd)})` : ""}  [${x.scheduleId.slice(0, 8)}]`).join("\n")}
+`
+      );
+      const answer = await o.ask(
+        `Which one should Rewake continue now? (1-${pending.length}, or Enter to keep waiting) `
+      );
+      const one = pending[Number(answer.trim()) - 1];
+      if (!one) {
+        o.out("Nothing was changed.\n");
+        return 1;
+      }
+      s = one;
+    }
+  }
+  const host = hostFor(o, s.host);
+  const noun = host?.noun ?? "session";
+  const place = host ? placeOf(host, s.cwd) : "that session";
+  const reopen = host?.reopen ?? `open the ${noun}`;
+  if (TERMINAL_STATUSES.has(s.status)) {
+    o.out(
+      `Nothing to continue: the resume of ${place} ${s.status === "sent" ? "was already sent" : s.status === "cancelled" ? "was cancelled" : "has already ended"}.
+`
+    );
+    return 0;
+  }
+  if (s.status === "sending") {
+    o.out(`Rewake is already continuing ${place}. It finishes on its own.
+`);
+    return 1;
+  }
+  if (!WAITING.has(s.status)) {
+    o.out(
+      `The resume of ${place} isn't waiting for the reset any more (${s.status.replace("_", " ")}), so there is nothing to run now. ${capital2(reopen)} to continue it yourself.
+`
+    );
+    return 1;
+  }
+  const window = o.hosts.find((h) => h.id === s.host && h.maxWaitAfterLimitMs !== void 0);
+  if (window) {
+    o.out(
+      `Rewake can't continue ${place} from here: ${windowReason(window)}. Type /rewake in the ${noun}, or ${reopen} to continue it yourself.
+`
+    );
+    return 1;
+  }
+  o.out(
+    `Rewake will continue ${place} now, without waiting for the reset (planned ${formatAt(s.dueAt, now)}).
+  Message, sent once as if you had typed it: "${oneLine2(s.text)}"
+Nothing is sent, and your resume stays planned for its time, if you typed in the ${noun} since the limit, if it is open or has changed, if the agent has already continued, if the usage limit is still on, or if the message can't reach the agent (signed out, session deleted or archived, folder gone).
+This window stays busy until the agent finishes (up to 3 hours); waiting for a free place to run can take a few minutes. Ctrl+C stops it and cancels this planned resume.
+`
+  );
+  if (o.yes !== true && !/^y(es)?$/i.test((await o.ask("Continue it now? [y/N] ")).trim())) {
+    o.out("Nothing was changed.\n");
+    return 1;
+  }
+  const outcome2 = await o.fireNow?.(s.scheduleId) ?? "not-ours";
+  const after = store.get(s.scheduleId);
+  switch (outcome2) {
+    case "sent":
+      o.out(`Rewake continued ${place}. ${capital2(reopen)} to see what it did.
+`);
+      return 0;
+    case "limited":
+      o.out(
+        `The usage limit is still on, so nothing was sent. Your resume is still planned for ${formatAt(s.dueAt, now)}.
+`
+      );
+      return 0;
+    case "open":
+      o.out(
+        `The ${noun} is open, so nothing was sent. Close it and run this again, or it still resumes at ${formatAt(s.dueAt, now)}.
+`
+      );
+      return 1;
+    case "changed":
+      o.out(
+        `The ${noun} has changed since it stopped, so nothing was sent. Your resume is still planned for ${formatAt(s.dueAt, now)}, and will send nothing then either. ${capital2(reopen)} to continue it yourself, or cancel the plan: ${rewake(`continue --cancel ${s.scheduleId.slice(0, 8)}`)}
+`
+      );
+      return 1;
+    case "typed":
+    case "native":
+      o.out(
+        `${outcome2 === "typed" ? `You typed in the ${noun} after the limit` : "The agent has already continued by itself"}, so nothing was sent. Your resume is still planned for ${formatAt(s.dueAt, now)}, and will send nothing then either. To remove it: ${rewake(`continue --cancel ${s.scheduleId.slice(0, 8)}`)}
+`
+      );
+      return 1;
+    case "skipped":
+      if (after?.failureReason !== "you") o.out("Rewake sent nothing.\n");
+      return 1;
+    case "busy":
+      o.out(`Rewake is already working on ${place}. Try again in a minute.
+`);
+      return 1;
+    case "notified":
+    case "failed":
+      if (after && WAITING.has(after.status))
+        o.out(`Your resume is still planned for ${formatAt(after.dueAt, now)}.
+`);
+      return 1;
+    default:
+      o.out(`Nothing was sent: the resume of ${place} had changed or ended.
+`);
+      return 1;
+  }
+}
+var windowReason, WAITING, capital2;
 var init_continue = __esm({
   "src/continue.ts"() {
     "use strict";
@@ -13876,9 +14127,13 @@ var init_continue = __esm({
     init_time();
     init_closed();
     init_sessions();
+    init_overview();
     init_command2();
     init_printable();
     init_sleep_settings();
+    windowReason = (h) => `${h.name} can only be continued from the window that is waiting for it, within 4 hours of its usage limit`;
+    WAITING = /* @__PURE__ */ new Set(["scheduled", "waiting_for_limit"]);
+    capital2 = (text2) => `${text2.charAt(0).toUpperCase()}${text2.slice(1)}`;
   }
 });
 
@@ -14364,7 +14619,7 @@ function diagnose(ctx) {
       area: "Rewake",
       level: "todo",
       text: "Zed starts Rewake through npm or one Node.js folder. An upgrade of that Node.js, or no network, can stop those agents from starting.",
-      fix: `Run the install command again, then quit Zed completely and open it again: ${update}`
+      fix: `Run the install command again: ${update}  Then ${reloadAgent(platform6)}.`
     });
   const pins = /* @__PURE__ */ new Set();
   for (const entry of wrappedEntries) {
@@ -14377,7 +14632,7 @@ function diagnose(ctx) {
         area: "Rewake",
         level: "todo",
         text: `Zed starts Rewake ${pin}; this is Rewake ${ctx.version}.`,
-        fix: `To update, run: ${update}  Then quit Zed completely and open it again.`
+        fix: `To update, run: ${update}  Then ${reloadAgent(platform6)}.`
       });
     else if (compareVersions(pin, ctx.version) > 0)
       add({
@@ -14846,7 +15101,7 @@ var init_doctor = __esm({
 });
 
 // src/doctor-report.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import { join as join37 } from "node:path";
 function redactor(home, ids) {
   const homes = [.../* @__PURE__ */ new Set([home, home.replace(/\\/g, "/")])].filter((h) => h.length > 1);
@@ -14949,7 +15204,7 @@ var init_doctor_report = __esm({
     LEFT_OUT = /* @__PURE__ */ new Set(["pid", "text", "prompt", "body", "content", "title", "cwd", "folder"]);
     FIRE_EVENTS = /^(fire\.|hook$|hook\.|limit\.|schedule\.settled|schedule\.delivering)/;
     short2 = (s) => s.slice(0, 8);
-    hash = (id) => createHash4("sha256").update(id).digest("hex");
+    hash = (id) => createHash5("sha256").update(id).digest("hex");
     iso = (t) => new Date(t).toISOString();
   }
 });
@@ -15411,7 +15666,9 @@ var init_settings_command = __esm({
       "auto-when-prompts-skipped",
       "clock",
       "keep-awake",
-      "resume-prompt"
+      "resume-prompt",
+      "workspace-changed",
+      "usage-warnings"
     ];
     SETTINGS = [
       {
@@ -15478,6 +15735,40 @@ var init_settings_command = __esm({
           return v && v !== DEFAULT_RESUME_PROMPT ? { ...rest, resumePrompt: v } : rest;
         },
         saved: (v) => v && v !== DEFAULT_RESUME_PROMPT ? "Resumes send your message from now on." : "Resumes send Rewake's own message again."
+      },
+      {
+        name: "workspace-changed",
+        title: "Project changed while waiting",
+        short: "What Rewake does when the project changed while a resume waited, outside Zed.",
+        more: "It compares the project's latest git commit and its tracked files (their names and status, never their contents, only on this computer).",
+        choices: () => [
+          ["tell", "Only tell you, and send the message as it is"],
+          ["note", "Also add a line asking the agent to re-read files before editing"],
+          ["hold", "Send nothing and ask you first"],
+          ["off", "Don't check"]
+        ],
+        get: (s) => s.workspaceChanged,
+        set: (s, v) => ({
+          ...s,
+          workspaceChanged: WORKSPACE_CHANGED_VALUES.find((x) => x === v) ?? s.workspaceChanged
+        }),
+        saved: (v) => v === "hold" ? "When the project changed while a resume waited, Rewake sends nothing and tells you." : v === "off" ? "Rewake won't check whether the project changed while a resume waited." : v === "note" ? "When the project changed while a resume waited, Rewake tells you and adds a line asking the agent to re-read files." : "When the project changed while a resume waited, Rewake tells you and sends the message as it is."
+      },
+      {
+        name: "usage-warnings",
+        title: "Warnings before a usage limit",
+        short: "Whether Claude Code warns you when a usage window is nearly used up.",
+        more: "Claude Code only. It uses Claude Code's own usage figures, with no network and no sign-in, and never types anything for you.",
+        choices: () => [
+          ["on", "Warn at 80% and 95% used, and when the pace would reach the limit within 45 minutes"],
+          ["off", "Don't warn"]
+        ],
+        get: (s) => s.usageWarnings,
+        set: (s, v) => ({
+          ...s,
+          usageWarnings: USAGE_WARNINGS_VALUES.find((x) => x === v) ?? s.usageWarnings
+        }),
+        saved: (v) => v === "off" ? "Claude Code won't warn you before a usage limit." : "Claude Code warns you at 80% and 95% of a usage limit, and when your pace would reach it within 45 minutes."
       }
     ];
     orList2 = (v) => v.length < 2 ? v[0] ?? "" : `${v.slice(0, -1).join(", ")} or ${v.at(-1)}`;
@@ -15781,10 +16072,12 @@ var init_help = __esm({
       {
         name: "continue",
         summary: "Continue a closed agent session after its usage limit",
-        usage: ["continue [--always | --ask | --cancel [<id>]]"],
+        usage: ["continue [--always | --ask | --cancel [<id>] | --now [<id>] [--yes]]"],
         about: [
           "Continues a session you closed at its usage limit, when the limit resets. Run alone, it asks",
-          "which session and when."
+          "which session and when.",
+          "--now is for a planned resume outside Zed that shouldn't wait for the reset (you upgraded",
+          "your plan, or the limit lifted early). In Zed, use Rewake \u2192 Change a scheduled message\u2026."
         ],
         options: [
           { flag: "--always", text: "Continue sessions by itself from now on" },
@@ -15792,11 +16085,27 @@ var init_help = __esm({
           {
             flag: "--cancel",
             text: "Cancel a planned resume: pick it, or give its id"
+          },
+          {
+            flag: "--now",
+            arg: "[<id>]",
+            text: "Continue a planned resume now, without waiting for the reset (outside Zed)"
+          },
+          {
+            flag: "--yes",
+            alias: "-y",
+            text: "With --now: don't ask first (needed without a terminal)"
           }
         ],
         footer: [
-          "With several planned and a terminal, --cancel lists them to pick one, or all. The ids are",
-          "in square brackets in `agent-rewake schedules`."
+          "With several planned and a terminal, --cancel and --now list them to pick one (--cancel also",
+          "all). --now shows what it will send and asks first; without a terminal it needs the id and",
+          "--yes. It stays busy until the agent finishes; Ctrl+C stops it and cancels that resume. If the",
+          "limit is still on, the session is open or changed, you typed after the limit, the agent",
+          "continued, or the message can't reach the agent (signed out, session deleted or archived,",
+          "folder gone), nothing is sent and the resume stays planned. Other errors end it as failed.",
+          "The ids are in square",
+          "brackets in `agent-rewake schedules`."
         ]
       },
       {
@@ -16916,7 +17225,10 @@ function codexAdapter(deps) {
       try {
         const started = s.attempts.length > 0 ? Math.min(...s.attempts.map((a) => a.startedAt)) : void 0;
         if (started === void 0) return void 0;
-        return userMessages(readTail2(transcript, 512 * 1024), started).includes(s.text) || void 0;
+        const sent = [s.text, `${s.text}
+
+${WORKSPACE_NOTE}`];
+        return userMessages(readTail2(transcript, 512 * 1024), started).some((m) => sent.includes(m)) || void 0;
       } catch {
         return void 0;
       }
@@ -16943,6 +17255,7 @@ var init_adapter = __esm({
   "src/hosts/codex/adapter.ts"() {
     "use strict";
     init_resume();
+    init_workspace();
     init_cli();
     init_rollout();
   }
@@ -16994,7 +17307,10 @@ function codexHooks(deps) {
       }
     };
     store.put(resume);
-    if (deps.arm(resume.scheduleId, at) !== false) return true;
+    if (deps.arm(resume.scheduleId, at) !== false) {
+      withWorkspace(store, resume, ctx.now);
+      return true;
+    }
     store.cancel(resume.scheduleId, ctx.now);
     return false;
   };
@@ -18816,9 +19132,17 @@ import { basename as basename10 } from "node:path";
 function runningText(at, noun = "session") {
   return `${at}: Rewake is continuing the ${noun} now. You'll get a notification when it's done. To stop it: "${rewake("continue --cancel")}".`;
 }
+function foregroundText(at, noun = "session") {
+  return `${at}: Rewake is continuing the ${noun} now. Press Ctrl+C to stop it.`;
+}
 function doneText(at, noun = "session", now = Date.now()) {
   return `${at}: Rewake's run ended normally ${formatAt(now, now)}. Open the ${noun} to see what it did.`;
 }
+function workspaceNoteText(noun, added) {
+  const what = `The project's tracked files or latest commit changed while the ${noun} waited`;
+  const how = added ? "so Rewake added a line to its message asking the agent to re-read files before editing." : "Rewake sent its message as it was. To have it add a line asking the agent to re-read files, choose note; to have it ask you first, choose hold.";
+  return `${what}${added ? "," : "."} ${how} Change this with: ${rewake("settings workspace-changed")} (tell, note, hold or off).`;
+}
 function where(host, s) {
   const folder = s.cwd ? basename10(s.cwd) : "";
   return folder ? `${host.name} in the "${folder}" folder` : host.name;
@@ -18832,6 +19156,13 @@ function notice(why, agent, now, f) {
       return `${agent}: the usage limit has reset. The ${n} is open, so Rewake didn't send anything. Continue it there.`;
     case "changed":
       return `${agent}: the usage limit has reset, but the ${n} has changed since it stopped, so Rewake didn't send anything. ${cap(reopen)} to see where it stands and continue.`;
+    case "workspace": {
+      const what = [
+        ...f.workspace?.commit ? ["its latest commit moved"] : [],
+        ...f.workspace?.changes ? ["its tracked files differ"] : []
+      ].join(" and ");
+      return `${agent}: the usage limit has reset, but the project changed while the ${n} waited (${what}), so Rewake didn't send anything. ${f.again ? f.again(void 0) : `To continue anyway, run "${rewake("continue")}", or ${reopen}.`} Change this check with: ${rewake("settings workspace-changed")} (tell, note, hold or off).`;
+    }
     case "late":
       return `${agent}: Rewake was due to continue the ${n}${f.dueAt ? ` ${formatAt(f.dueAt, now)}` : ""}, but couldn't run then (the computer may have been off or asleep). ${cap(reopen)} to continue.`;
     case "far-reset":
@@ -18880,6 +19211,14 @@ function rearmEarly(id, store, deps, now) {
   deps.log?.("fire.early", { armed: armed.ok });
   return "early";
 }
+function keptOutcome(d) {
+  if (d.action === "notify") return d.why === "open" || d.why === "changed" ? d.why : "limited";
+  if (d.action === "skip") {
+    if (d.why === "typed" || d.why === "native") return d.why;
+    return d.why === "expired" ? "limited" : "gone";
+  }
+  return "limited";
+}
 async function fire(id, deps) {
   const store = new ScheduleStore(deps.stateDir);
   const log = deps.log ?? (() => {
@@ -18905,7 +19244,7 @@ async function fire(id, deps) {
   }
   const lock = new SessionLock(deps.stateDir);
   const lockKey = `fire:${id}`;
-  if (first.status !== "cancelled" && now < first.dueAt - EARLY_MS) {
+  if (!deps.immediate && first.status !== "cancelled" && now < first.dueAt - EARLY_MS) {
     if (!lock.acquire(lockKey)) return "early";
     try {
       return rearmEarly(id, store, deps, now);
@@ -18931,7 +19270,7 @@ async function fire(id, deps) {
       removeTimer();
       return "gone";
     }
-    if (s.status !== "cancelled" && now < s.dueAt - EARLY_MS)
+    if (!deps.immediate && s.status !== "cancelled" && now < s.dueAt - EARLY_MS)
       return rearmEarly(id, store, deps, now);
     const wait2 = (until, why, count = true) => {
       const next = Math.max(until, now + MIN_ARM_MS);
@@ -18964,7 +19303,10 @@ async function fire(id, deps) {
       const place = await takeSlot({ stateDir: deps.stateDir, ...deps.slots }).catch(
         () => "error"
       );
-      if (place === void 0) return wait2(now + MIN_ARM_MS, "no-free-place", false);
+      if (place === void 0) {
+        if (deps.immediate) return "busy";
+        return wait2(now + MIN_ARM_MS, "no-free-place", false);
+      }
       if (place !== "error") slot.release = place;
     }
     const settings = loadSettings(deps.stateDir);
@@ -18977,7 +19319,7 @@ async function fire(id, deps) {
       }
     const decision = decideFire({
       resume: {
-        dueAt: s.dueAt,
+        dueAt: deps.immediate ? now : s.dueAt,
         status: s.status,
         ...s.rearms !== void 0 && { rearms: s.rearms }
       },
@@ -18997,7 +19339,7 @@ async function fire(id, deps) {
       }),
       now
     );
-    const tell = (why, status, cause, message) => {
+    const tell = (why, status, cause, message, workspace) => {
       settle(status, cause ?? why, message);
       if (facts.newResetsAt !== void 0 && (why === "far-reset" || why === "expired"))
         store.update(id, (x) => ({ ...x, dueAt: (facts.newResetsAt ?? 0) + RESET_MARGIN_MS }), now);
@@ -19010,12 +19352,17 @@ async function fire(id, deps) {
           ...host.again !== void 0 && { again: host.again },
           dueAt: s.dueAt,
           ...facts.newResetsAt !== void 0 && { resetsAt: facts.newResetsAt },
-          ...cause && { cause }
+          ...cause && { cause },
+          ...workspace && { workspace }
         })
       );
       removeTimer();
       return why === "failed" || why === "expired" ? "failed" : "notified";
     };
+    if (deps.immediate && decision.action !== "send") {
+      log("fire.kept", { host: host.id, action: decision.action });
+      return keptOutcome(decision);
+    }
     log("fire.decide", {
       host: host.id,
       action: decision.action,
@@ -19023,6 +19370,19 @@ async function fire(id, deps) {
     });
     switch (decision.action) {
       case "send": {
+        let noted = false;
+        let changed = false;
+        if (s.workspace && settings.workspaceChanged !== "off") {
+          const here = fingerprintWorkspace(s.cwd, FIRE_BUDGET_MS);
+          const differs = here && workspaceChange(s.workspace, here);
+          if (differs) {
+            log("fire.workspace", { action: settings.workspaceChanged });
+            if (settings.workspaceChanged === "hold")
+              return tell("workspace", "needs_attention", void 0, void 0, differs);
+            changed = true;
+            noted = settings.workspaceChanged === "note";
+          }
+        }
         const claimed = store.update(
           id,
           (x) => x.status !== s.status || x.dueAt !== s.dueAt ? void 0 : {
@@ -19050,6 +19410,7 @@ async function fire(id, deps) {
         const wake = deps.wake ?? new Wakefulness();
         wake.set(true, settings.keepAwake);
         let watch2;
+        let told = false;
         onResumeRun((pid) => {
           store.update(
             id,
@@ -19059,7 +19420,12 @@ async function fire(id, deps) {
             }),
             now
           );
-          deps.notify("Agent Rewake", runningText(at, host.noun));
+          told = changed;
+          const running = deps.immediate ? foregroundText(at, host.noun) : runningText(at, host.noun);
+          deps.notify(
+            "Agent Rewake",
+            changed ? `${running} ${workspaceNoteText(host.noun, noted)}` : running
+          );
           watch2 = setInterval(() => {
             if (!store.get(id)?.attempts.find((a) => a.idempotencyKey === key2)?.stopped) return;
             clearInterval(watch2);
@@ -19067,7 +19433,12 @@ async function fire(id, deps) {
           }, deps.stopPollMs ?? STOP_POLL_MS);
         });
         try {
-          result = await host.send(s, key2);
+          result = await host.send(
+            noted ? { ...s, text: `${s.text}
+
+${WORKSPACE_NOTE}` } : s,
+            key2
+          );
         } catch (err) {
           result = { ok: false, reason: "failed", detail: err.message };
         } finally {
@@ -19075,7 +19446,7 @@ async function fire(id, deps) {
           if (watch2) clearInterval(watch2);
           wake.release();
         }
-        if (store.get(id)?.attempts.find((a) => a.idempotencyKey === key2)?.stopped) {
+        if (store.get(id)?.attempts.find((a) => a.idempotencyKey === key2)?.stopped && !(deps.immediate && result.ok)) {
           settle("stopped", "you");
           removeTimer();
           log("fire.stopped", {});
@@ -19093,10 +19464,25 @@ async function fire(id, deps) {
         if (result.ok) {
           settle("sent");
           removeTimer();
-          if (store.get(id)?.attempts.find((a) => a.idempotencyKey === key2)?.pid !== void 0)
+          if (changed && !told)
+            deps.notify("Agent Rewake", `${at}: ${workspaceNoteText(host.noun, noted)}`);
+          if (!deps.immediate && store.get(id)?.attempts.find((a) => a.idempotencyKey === key2)?.pid !== void 0)
             deps.notify("Agent Rewake", doneText(at, host.noun, deps.now()));
           return "sent";
         }
+        if (deps.immediate && (result.reason === "limited" || result.reason === "busy")) {
+          store.update(
+            id,
+            (x) => ({
+              ...x,
+              status: s.status,
+              attempts: x.attempts.filter((a) => a.idempotencyKey !== key2)
+            }),
+            now
+          );
+          log("fire.still-limited", { host: host.id, now: true });
+          return result.reason === "limited" ? "limited" : "busy";
+        }
         if (result.reason === "limited" || result.reason === "busy") {
           const rearms = s.rearms ?? 0;
           const reset = result.reason === "limited" ? result.resetsAt : void 0;
@@ -19118,6 +19504,27 @@ async function fire(id, deps) {
           "needs-approval",
           "folder-gone"
         ].includes(result.detail ?? "") ? result.detail : void 0;
+        if (deps.immediate && cause !== void 0 && !["timeout", "needs-approval"].includes(cause)) {
+          store.update(
+            id,
+            (x) => ({
+              ...x,
+              status: s.status,
+              attempts: x.attempts.filter((a) => a.idempotencyKey !== key2)
+            }),
+            now
+          );
+          deps.notify(
+            "Agent Rewake",
+            notice("failed", at, now, {
+              noun: host.noun,
+              agentName: host.name,
+              ...host.reopen !== void 0 && { reopen: host.reopen },
+              cause
+            })
+          );
+          return "failed";
+        }
         return tell("failed", "failed", cause, result.message);
       }
       case "wait":
@@ -19193,6 +19600,7 @@ var init_fire = __esm({
     init_command2();
     init_keep_awake();
     init_spawn2();
+    init_workspace();
     init_slots();
     init_timers();
     EARLY_MS = 3e4;
@@ -21277,14 +21685,23 @@ ${loginItemPlanText(process.platform)}`);
     return code3;
   }
   if (first === "continue") {
+    if (argv.includes("--now")) {
+      const rest = argv.slice(1).filter((a) => a !== "--now");
+      const yes = rest.some((a) => a === "--yes" || a === "-y");
+      const names = rest.filter((a) => a !== "--yes" && a !== "-y");
+      const nowId = names[0];
+      if (names.length > 1 || nowId?.startsWith("-")) {
+        process.stderr.write(CONTINUE_USAGE);
+        return 2;
+      }
+      return runContinueCommand(env, "now", void 0, nowId, yes);
+    }
     const flag = argv[1];
     const mode = flag === "--always" ? "always" : flag === "--ask" ? "ask" : flag === "--cancel" ? "cancel" : void 0;
     const cancelId = mode === "cancel" ? argv[2] : void 0;
     const extra = argv.length > (cancelId === void 0 ? 2 : 3);
     if (flag !== void 0 && mode === void 0 || extra || cancelId?.startsWith("-")) {
-      process.stderr.write(
-        "agent-rewake: usage: agent-rewake continue [--always | --ask | --cancel [<id>]]\n"
-      );
+      process.stderr.write(CONTINUE_USAGE);
       return 2;
     }
     return runContinueCommand(env, mode, cancelId);
@@ -22014,14 +22431,70 @@ async function prompt(question) {
     rl.close();
   }
 }
-async function runContinueCommand(env, mode, cancelId) {
+async function runContinueCommand(env, mode, cancelId, nowId, yes = false) {
   const { state, timers, sweepDeps, node } = timerDeps(env);
   sweepQuietly(env);
   const adapters = hostAdapters(env, node, state);
-  return runContinue({
+  const log = new Logger(env);
+  let interrupted = false;
+  let sentAnyway = false;
+  const code2 = await runContinue({
     sleepSettings: () => readSleepSettings({ env }),
     ...mode && { mode },
     ...cancelId !== void 0 && { cancelId },
+    ...nowId !== void 0 && { nowId },
+    yes,
+    // The resume's own timer run, at once; what it would tell by notification is said here.
+    fireNow: async (id) => {
+      const store = new ScheduleStore(state);
+      const onInterrupt = () => {
+        if (interrupted) {
+          const pid = store.get(id)?.attempts.at(-1)?.pid;
+          if (pid !== void 0) {
+            killPidTree(pid, void 0, void 0, "SIGKILL");
+            process.stdout.write("Ended the agent now.\n");
+          }
+          return;
+        }
+        interrupted = true;
+        const s = store.get(id);
+        if (s !== void 0 && s.status !== "sending" && !WAITING_STATES.has(s.status)) return;
+        if (s?.status !== "sending") {
+          process.stdout.write("Stopped. Nothing was sent, and your resume is still planned.\n");
+          process.exit(130);
+        }
+        store.update(
+          id,
+          (x) => ({
+            ...x,
+            attempts: x.attempts.map(
+              (a, i) => i === x.attempts.length - 1 ? { ...a, stopped: true } : a
+            )
+          }),
+          Date.now()
+        );
+        process.stdout.write(
+          "Stopping. The agent ends within a few seconds; what it has done so far stays. The planned resume is cancelled too.\n"
+        );
+      };
+      process.on("SIGINT", onInterrupt);
+      try {
+        const outcome2 = await fire(id, {
+          stateDir: state,
+          now: Date.now,
+          hosts: adapters,
+          timers,
+          notify: (_title, body) => process.stdout.write(`${body}
+`),
+          log: (event, fields2) => log.info(event, fields2),
+          immediate: true
+        });
+        sentAnyway = outcome2 === "sent";
+        return outcome2;
+      } finally {
+        process.off("SIGINT", onInterrupt);
+      }
+    },
     // Codex's resumes too, which `continue` doesn't arm itself.
     hostOf: (id) => adapters.get(id),
     hosts: CLOSED_HOSTS,
@@ -22041,11 +22514,12 @@ async function runContinueCommand(env, mode, cancelId) {
     err: (t) => process.stderr.write(t),
     ask: prompt
   });
+  return interrupted && !sentAnyway ? 130 : code2;
 }
 function previewNames(env) {
   return installedPreviews(env, homedir23(), stateDir(env)).map((id) => PREVIEW_NAMES[id] ?? id);
 }
-var INSTALL_PLACES, KNOWN_OPTIONS, TIMER_PLACES;
+var INSTALL_PLACES, KNOWN_OPTIONS, WAITING_STATES, CONTINUE_USAGE, TIMER_PLACES;
 var init_cli2 = __esm({
   "src/cli.ts"() {
     "use strict";
@@ -22120,6 +22594,8 @@ var init_cli2 = __esm({
       schedules: ["--all", "--json", "--explain"],
       history: ["--days"]
     };
+    WAITING_STATES = /* @__PURE__ */ new Set(["scheduled", "waiting_for_limit"]);
+    CONTINUE_USAGE = "agent-rewake: usage: agent-rewake continue [--always | --ask | --cancel [<id>] | --now [<id>] [--yes]]\n";
     TIMER_PLACES = /* @__PURE__ */ new Set([
       "codex",
       "copilot-cli",

package/dist/hosts/claude-code/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "rewake",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Continues this session when your usage limit resets, and sends messages you schedule into it.",
   "author": {
     "name": "Codize Labs",

package/dist/hosts/claude-code/hooks/logic.js

@@ -76,6 +76,104 @@ export function blockingKind(rateLimits, now) {
   )?.kind;
 }
 
+// ---- Warnings before a limit: Claude Code's own usage figures, no network, no sign-in.
+
+/** Percent used at which a window is warned about, lowest first. */
+const WARN_AT = [80, 95];
+/** Samples kept per window, and the least time they must span before a pace is trusted. */
+const SAMPLE_CAP = 12;
+const MIN_SPAN_MS = 10 * MINUTE;
+/** Only readings this recent give the pace. */
+const RECENT_MS = HOUR;
+/** A pace warning comes when the projected limit is this near. */
+const PACE_HORIZON_MS = 45 * MINUTE;
+/** Two reset times closer than this are the same window (the figures can differ by a moment). */
+const SAME_WINDOW_MS = 30 * MINUTE;
+
+/**
+ * Milliseconds until the window reaches 100, from its samples ({ t, p }: time, percent used), or
+ * undefined when the pace is unknown: the figure has not moved since the newest sample (so idle
+ * time never counts as a pace), fewer than two samples from the last hour, those less than 10
+ * minutes apart, or no rise.
+ */
+export function timeToLimit(samples, now) {
+  const recent = samples.filter((s) => s.t >= now - RECENT_MS);
+  const first = recent[0];
+  const last = recent.at(-1);
+  if (!first || !last || last.t !== now || last.t - first.t < MIN_SPAN_MS) return undefined;
+  const rate = (last.p - first.p) / (last.t - first.t);
+  return rate > 0 ? (100 - last.p) / rate : undefined;
+}
+
+/** The estimate as a range of whole minutes in fives, about 0.7x to 1.4x: [20, 40]. */
+export function paceRange(ms) {
+  const five = (x) => Math.max(5, Math.round(x / (5 * MINUTE)) * 5);
+  const lo = five(ms * 0.7);
+  return [lo, Math.max(lo + 5, five(ms * 1.4))];
+}
+
+/**
+ * One window's reading, given what was kept for it (`prev`: { resetsAt, samples, high, pace },
+ * or undefined). Returns undefined when there is nothing to track (a spending cap, no reset ahead,
+ * a full window: the limit flow takes over), else { next, level?, pace? }: the state to keep, the
+ * threshold newly crossed (only the highest if it jumped past both) and the pace range to warn
+ * with. A threshold is warned once per window, the pace once per window and never together with
+ * a threshold (it waits for the next reading).
+ */
+export function usageStep(prev, w, now) {
+  const reset = typeof w.resetsAt === "string" ? Date.parse(w.resetsAt) : Number.NaN;
+  const p = w.percentUsed;
+  if (BILLING_KINDS.has(w.kind) || !Number.isFinite(reset) || reset <= now) return undefined;
+  if (!(p >= 0 && p < 100)) return undefined;
+  const same = prev && Math.abs(prev.resetsAt - reset) < SAME_WINDOW_MS;
+  const base = same ? prev : { resetsAt: reset, samples: [], high: 0, pace: false };
+  const last = base.samples.at(-1);
+  const samples =
+    last?.p === p ? base.samples : [...(last && p < last.p ? [] : base.samples), { t: now, p }];
+  const kept = samples.slice(-SAMPLE_CAP);
+  const level = WARN_AT.filter((l) => p >= l && l > base.high).pop();
+  const ms = level === undefined && !base.pace ? timeToLimit(kept, now) : undefined;
+  const pace =
+    ms !== undefined && ms <= PACE_HORIZON_MS && now + ms < reset ? paceRange(ms) : undefined;
+  return {
+    next: {
+      resetsAt: reset, // the latest, so a slowly drifting time can't make the window look new
+      samples: kept,
+      high: level ?? base.high,
+      pace: base.pace || pace !== undefined,
+    },
+    level,
+    pace,
+  };
+}
+
+/** "5-hour limit", "7-day limit", "7-day opus limit", "some kind limit". */
+export function limitName(kind) {
+  const m = /^seven_day_(.+)$/.exec(kind);
+  const name =
+    kind === "five_hour"
+      ? "5-hour"
+      : kind === "seven_day"
+        ? "7-day"
+        : m
+          ? `7-day ${m[1].replace(/_/g, " ")}`
+          : String(kind).replace(/_/g, " ");
+  return `${name} limit`;
+}
+
+/** `reset` is the reset time as words: "at 3:00 AM today", "on Friday at 9:00 AM". */
+export function levelText(kind, percent, reset) {
+  const head = `${limitName(kind)}: ${Math.floor(percent)}% used, as of Claude Code's last reply. It resets ${reset}.`;
+  // Compacting is a model call too, so it is only hinted at below 95%.
+  return percent >= 95
+    ? `${head} A good moment to wrap up or save what you are doing.`
+    : `${head} If you are in the middle of a task, /compact now can make the rest last longer (compacting also uses some).`;
+}
+
+export function paceText(kind, [lo, hi], reset) {
+  return `At this pace you reach the ${limitName(kind)} in about ${lo} to ${hi} minutes, before it resets ${reset}.`;
+}
+
 /**
  * Claude Code's own panels, by `CLAUDE_CODE_ENTRYPOINT`: the VS Code extension (also in Cursor and
  * other VS Code builds) and the desktop app. They run Claude Code through the Agent SDK, so the

package/dist/hosts/claude-code/hooks/register.js

@@ -13,6 +13,10 @@
 //                        offered (not answered) | armed | sent
 //                 claim: { by, at }, the process sending the armed continue right now
 //   sched:<id>    [{ at, text }]
+//   usage:<dir>   { <kind>: { resetsAt, samples: [{ t, p }], high, pace } }, what the warnings
+//                 before a limit have said. The figures are the account's, not the session's, so
+//                 the key is the config dir (CLAUDE_CONFIG_DIR, which is one sign-in): a restart or
+//                 another session of the same account doesn't repeat a warning.
 // A copy of each limit record (no message text) goes to Rewake's shared state folder, so
 // `agent-rewake doctor` and the schedules page can show it, and so Rewake can continue the session
 // headless if Claude Code closes before the limit is answered (it adds `open`, the Claude Code
@@ -34,6 +38,7 @@ import {
   helpText,
   holdArgv,
   LINUX_MAINS,
+  levelText,
   limitOf,
   MAX_REARMS,
   MAX_REHITS,
@@ -42,6 +47,7 @@ import {
   mustAsk,
   nativeLikely,
   notHere,
+  paceText,
   parseCommand,
   parseProcess,
   parseProgram,
@@ -54,6 +60,7 @@ import {
   sessionVars,
   splitWhen,
   surfaceOf,
+  usageStep,
   WAITING_EXPIRES_MS,
   WAKE_HORIZON_MS,
   WAKE_PROBE,
@@ -106,6 +113,10 @@ const ME = Math.random().toString(36).slice(2);
 const CLAIM_MS = 5 * MINUTE;
 /** Rewake's keep-awake setting: "plugged-in" (default), "always" or "never". */
 let keepAwake = "plugged-in";
+/** Rewake's usage-warnings setting: "on" (default) or "off". */
+let usageWarnings = "on";
+/** CLAUDE_CONFIG_DIR, which names the account's warnings in $.store ("" for the default). */
+let configDir = "";
 /** { kind, pid, program }: Claude Code's PID and the hold program (macOS, Linux with systemd-inhibit, Windows); null where there is none. */
 let wakeTarget;
 /** The running hold: { key, stream }. */
@@ -131,6 +142,8 @@ async function loadConfig($) {
       if (["on", "off", "ask"].includes(settings.newThreads)) sharedAuto = settings.newThreads;
       if (["plugged-in", "always", "never"].includes(settings.keepAwake))
         keepAwake = settings.keepAwake;
+      if (settings.usageWarnings === "on" || settings.usageWarnings === "off")
+        usageWarnings = settings.usageWarnings;
     } catch {
       // No settings saved yet: the default clock.
     }
@@ -146,7 +159,7 @@ async function loadSessionInfo($) {
   // SETTINGS_VARS and KEY_VARS; a test in Rewake's repository compares them with these).
   const read = (get) => get.catch(() => undefined);
   const values = {
-    CLAUDE_CONFIG_DIR: await read($.env.get("CLAUDE_CONFIG_DIR")),
+    CLAUDE_CONFIG_DIR: configDir, // read once, at session start
     CLAUDE_CODE_PROJECT_DIR_NAME: await read($.env.get("CLAUDE_CODE_PROJECT_DIR_NAME")),
     ANTHROPIC_BASE_URL: await read($.env.get("ANTHROPIC_BASE_URL")),
     ANTHROPIC_MODEL: await read($.env.get("ANTHROPIC_MODEL")),
@@ -494,6 +507,26 @@ async function onMeasure($, rateLimits) {
   );
 }
 
+/** Toasts at 80% and 95% of a usage window, and when the pace would reach the limit soon. */
+async function warnUsage($, rateLimits) {
+  if (usageWarnings === "off" || !personAtPrompt({ isInteractive, entrypoint })) return;
+  const now = await $.clock.now();
+  const key = `usage:${configDir}`;
+  const state = (await $.store.get(key)) ?? {};
+  const toasts = [];
+  for (const w of rateLimits ?? []) {
+    const step = w && usageStep(state[w.kind], w, now);
+    if (!step) continue;
+    state[w.kind] = step.next;
+    const reset = atWhen(step.next.resetsAt, now);
+    if (step.level !== undefined) toasts.push(levelText(w.kind, w.percentUsed, reset));
+    else if (step.pace) toasts.push(paceText(w.kind, step.pace, reset));
+  }
+  // Saved before showing: a failure while showing must not make the same warning come back.
+  await $.store.set(key, state);
+  for (const text of toasts) $.ui.toast(text);
+}
+
 async function onNotification($, e) {
   const id = e.session_id;
   const ep = await $.store.get(limitKey(id));
@@ -859,6 +892,7 @@ export function register(on) {
     isInteractive = e.isInteractive;
     sessionCwd = e.cwd;
     entrypoint = await $.env.get("CLAUDE_CODE_ENTRYPOINT").catch(() => undefined);
+    configDir = (await $.env.get("CLAUDE_CONFIG_DIR").catch(() => undefined)) ?? "";
     inert = Boolean(await $.env.get("AGENT_REWAKE_FIRE").catch(() => undefined));
     if (inert) return next(e);
     surface = surfaceOf({ surface: e.surface, entrypoint });
@@ -905,7 +939,10 @@ export function register(on) {
   }).catch(passOn);
 
   on("session.measure", ($, e, next) => {
-    if (!inert && e.changed.includes("rateLimits")) void onMeasure($, e.rateLimits);
+    if (!inert && e.changed.includes("rateLimits")) {
+      void onMeasure($, e.rateLimits);
+      void warnUsage($, e.rateLimits).catch(() => undefined);
+    }
     return next(e);
   }).catch(passOn);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codizelabs/agent-rewake",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Auto-resume Claude Code, Codex, Gemini CLI, GitHub Copilot, Grok or any Zed agent when its usage limit resets, in the same session, and schedule messages into your agent threads.",
   "keywords": [
     "zed",