spacecode 2.11.0 → 2.12.0

package/dist/repl.mjs

@@ -4088,7 +4088,7 @@ var init_defaults_core_loop = __esm({
         body: `You are the core of a coding run. You direct; you never read files, search, run commands or write code. Workers do that.
 
 ## Tools (the only ones that exist)
-- edit_plan {tasks}: add tasks. Each task has id, role, goal (what the worker must do, concrete and self-contained: the worker sees only this, the files and the acceptance), files (a file belongs to one open task at a time), acceptance {kind: checks|rubric|none, detail}, budgetTokens, deadlineMs.
+- edit_plan {tasks}: add tasks. Each task has id, role, goal (what the worker must do, concrete and self-contained: the worker sees only this, the files and the acceptance), files (a file belongs to one open task at a time), acceptance {kind: checks|rubric|none, detail} (a code task that the repo can check, with tests or a typecheck, uses kind checks so the repo's own typecheck and tests must pass; rubric and none skip them), budgetTokens, deadlineMs (milliseconds; a worker needs minutes to clone, work and check, so use 600000 for a code task; values are clamped to 600000-840000).
 - dispatch_task {taskId}: start a pending task (at most 2 attempts per task).
 - accept_task {taskId}: accept a task in review. A checks task needs a passing verifier first.
 - drop_task {taskId, reason}: drop a task you no longer need.
@@ -4101,7 +4101,7 @@ var init_defaults_core_loop = __esm({
 - When the token budget is exhausted, package what is accepted and send the result.
 - Prefer small tasks with one owner per file. Stay inside the budget.
 - You are only woken by worker results and user messages, never by your own actions. So in the same answer as edit_plan, dispatch_task every task that can start now; a task left pending with nothing running stalls the run.
-- Tasks that must follow another (a test after its implementation) are dispatched after the earlier one is accepted.
+- Tasks that must follow another (a test after its implementation) are dispatched after the earlier one is accepted; the later worker starts from the accepted work, so give it only its own files and do not repeat the earlier task's work.
 - Worker digests are already included in what you are shown; there is nothing more to read. Decide from them (accept_task, drop_task, or dispatch a retry).
 - Make every tool call of your answer at once; you do not see results between calls. Reply with tool calls only.`
       },
@@ -104407,7 +104407,9 @@ async function runCoreTurn(d, prompt) {
   let lastText = "";
   const say = (content) => {
     lastText = content;
-    d.emit({ type: "text", seq: ++seq, content });
+    d.emit({ type: "text", seq: ++seq, content: `${content}
+
+` });
   };
   const call = async (method, path13, body) => {
     const res = await d.fetch(`${d.backendUrl}/api/core/runs${path13}`, {
@@ -104424,7 +104426,7 @@ async function runCoreTurn(d, prompt) {
     const created = await call("POST", "", {
       sessionId: d.sessionId,
       budgetTokens: d.budgetTokens ?? DEFAULT_BUDGET,
-      ...d.repo ? { repoUrl: d.repo.url, ...d.repo.branch ? { branch: d.repo.branch } : {} } : {}
+      ...d.repo ? { repoUrl: d.repo.url, ...d.repo.branch ? { branch: d.repo.branch } : {}, ...d.ghToken ? { ghToken: d.ghToken } : {} } : {}
     });
     runId = created.runId;
     d.setRunId(runId);
@@ -104433,23 +104435,21 @@ async function runCoreTurn(d, prompt) {
   const chat = await call("POST", `/${runId}/chat`, { id: d.newId(), text: prompt });
   if (chat.reply) say(chat.reply.text);
   else if (chat.replyError) say("(The quick reply is unavailable; the planner has your message.)");
-  let after = 0;
-  let known = {};
-  const patches = /* @__PURE__ */ new Map();
+  const cur = d.cursor;
   const startedAt = d.now();
   const maxWait = d.maxWaitMs ?? DEFAULT_MAX_WAIT_MS;
   let delay = 1e3;
   let state = null;
   for (; ; ) {
     if (d.signal.aborted) throw new CoreTurnError("aborted");
-    const events = (await call("GET", `/${runId}/events?after=${after}&limit=200`)).events;
+    const events = (await call("GET", `/${runId}/events?after=${cur.after}&limit=200`)).events;
     for (const e of events) {
-      after = Math.max(after, e.seq);
+      cur.after = Math.max(cur.after, e.seq);
       if (!e.applied) continue;
       const p = e.payload ?? {};
       if (e.type === "core_message" && typeof p.text === "string") say(p.text);
       if (e.type === "worker_done" && typeof p.taskId === "string") {
-        if (typeof p.patchKey === "string") patches.set(p.taskId, p.patchKey);
+        if (typeof p.patchKey === "string") cur.patches[p.taskId] = p.patchKey;
         if (Array.isArray(p.problems) || typeof p.reason === "string") say(`task ${p.taskId}: the worker's attempt failed${typeof p.reason === "string" ? ` (${p.reason})` : ""}`);
       }
       if (e.type === "verifier_result" && Array.isArray(p.problems) && p.problems.length > 0) say(`task ${String(p.taskId)}: verifier: ${p.problems.join("; ")}`);
@@ -104457,9 +104457,9 @@ async function runCoreTurn(d, prompt) {
     state = (await call("GET", `/${runId}`)).state;
     const now = {};
     for (const id of state.order) now[id] = state.tasks[id].status;
-    const changed = state.order.filter((id) => now[id] !== known[id]);
+    const changed = state.order.filter((id) => now[id] !== cur.known[id]);
     if (changed.length > 0) say(changed.map((id) => `task ${id}: ${now[id]}`).join(", "));
-    known = now;
+    cur.known = now;
     if (TERMINAL.has(state.status)) break;
     if (d.now() - startedAt > maxWait) throw new CoreTurnError("the run is still working after the wait limit; ask again later or check on it");
     delay = events.length > 0 ? 1e3 : Math.min(5e3, Math.round(delay * 1.5));
@@ -104467,22 +104467,29 @@ async function runCoreTurn(d, prompt) {
   }
   if (state.status === "core_failed") say('The planner failed on every model route. Say "continue" after a moment to resume this run.');
   if (state.status === "stopped") say("The run stopped before everything was accepted.");
+  let patchFailures = 0;
   for (const id of state.order) {
-    if (state.tasks[id].status !== "accepted" || !patches.has(id)) continue;
+    if (state.tasks[id].status !== "accepted" || !(id in cur.patches) || cur.applied.includes(id)) continue;
     const art = await d.fetch(`${d.backendUrl}/api/core/runs/${runId}/artifacts/${encodeURIComponent(id)}`, { headers: { authorization: `Bearer ${d.apiKey}` }, signal: d.signal });
     if (!art.ok) {
       say(`task ${id}: its patch could not be fetched (${art.status})`);
+      patchFailures++;
       continue;
     }
+    cur.applied.push(id);
     const result = await d.applyPatch({ taskId: id, patch: await art.text() });
     say(`task ${id}: ${result.applied ? "patch applied" : "patch not applied"} (${result.detail})`);
+    if (!result.applied) patchFailures++;
   }
-  return { success: state.status === "done" || state.status === "needs_user", text: lastText, tokens: state.tokensUsed };
+  const tokens = Math.max(0, state.tokensUsed - cur.tokensBase);
+  cur.tokensBase = state.tokensUsed;
+  return { success: (state.status === "done" || state.status === "needs_user") && patchFailures === 0, text: lastText, tokens };
 }
-var TERMINAL, DEFAULT_BUDGET, DEFAULT_MAX_WAIT_MS, CoreTurnError;
+var newRunCursor, TERMINAL, DEFAULT_BUDGET, DEFAULT_MAX_WAIT_MS, CoreTurnError;
 var init_core_turn = __esm({
   "src/core/core-turn.ts"() {
     "use strict";
+    newRunCursor = () => ({ after: 0, known: {}, patches: {}, applied: [], tokensBase: 0 });
     TERMINAL = /* @__PURE__ */ new Set(["done", "stopped", "core_failed", "needs_user"]);
     DEFAULT_BUDGET = 5e5;
     DEFAULT_MAX_WAIT_MS = 30 * 6e4;
@@ -104512,13 +104519,20 @@ async function detectRepo(cwd2, env3) {
   const branch = env3.SPACECODE_CORE_BRANCH?.trim();
   return { url, ...branch ? { branch } : {} };
 }
+function shareableGithubToken(env3) {
+  if (env3.SPACECODE_CORE_SHARE_GITHUB_TOKEN?.trim().toLowerCase() !== "on") return void 0;
+  const t = (env3.GH_TOKEN ?? env3.GITHUB_TOKEN)?.trim();
+  return t ? t : void 0;
+}
 function patchApplier(executor, cwd2, runId) {
   return async ({ taskId, patch }) => {
-    const dir = join14(cwd2, ".git", "spacecode-core", runId);
+    const top = await gitOut(cwd2, ["rev-parse", "--show-toplevel"]) ?? cwd2;
+    const gitDir = await gitOut(cwd2, ["rev-parse", "--absolute-git-dir"]) ?? join14(top, ".git");
+    const dir = join14(gitDir, "spacecode-core", runId.replace(/[^A-Za-z0-9_.-]/g, "_"));
     await mkdir6(dir, { recursive: true });
     const file = join14(dir, `${taskId.replace(/[^A-Za-z0-9_.-]/g, "_")}.patch`);
     await writeFile6(file, patch, { encoding: "utf-8", mode: 384 });
-    const res = await executor.execute("bash", { command: `git apply --3way ${JSON.stringify(file)}` });
+    const res = await executor.execute("bash", { command: `git -C ${sq(top)} apply --3way ${sq(file)}` });
     return res.is_error ? { applied: false, detail: `${res.output.slice(0, 200).trim() || "git apply failed"}; patch kept at ${file}` } : { applied: true, detail: "git apply --3way" };
   };
 }
@@ -104532,11 +104546,13 @@ async function runCoreForRepl(o) {
       apiKey: o.apiKey,
       sessionId: o.sessionId,
       repo,
+      ...shareableGithubToken(o.env) ? { ghToken: shareableGithubToken(o.env) } : {},
       getRunId: () => o.runIdRef.current,
       setRunId: (id) => {
         o.runIdRef.current = id;
         runIdForApply = id;
       },
+      cursor: o.cursor,
       newId: () => crypto.randomUUID(),
       sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
       now: Date.now,
@@ -104549,13 +104565,14 @@ async function runCoreForRepl(o) {
   const messages = [...o.history, { role: "user", content: o.prompt }, { role: "assistant", content: [{ type: "text", text: turn.text || "(no reply)" }] }];
   return { success: turn.success, messages, totalInputTokens: turn.tokens, totalOutputTokens: 0 };
 }
-var coreModeOn;
+var coreModeOn, sq;
 var init_core_mode = __esm({
   "src/core/core-mode.ts"() {
     "use strict";
     init_core_turn();
     init_profile_runtime();
     coreModeOn = (env3) => env3.SPACECODE_CORE?.trim().toLowerCase() === "on";
+    sq = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
   }
 });
 
@@ -104594,6 +104611,7 @@ function useReplController({ repoName: repoName2, yolo: yolo2, mentions: mention
   }, [projectRoot]);
   const sessionIdRef = (0, import_react30.useRef)(null);
   const coreRunIdRef = (0, import_react30.useRef)(null);
+  const coreCursorRef = (0, import_react30.useRef)(newRunCursor());
   const sessionCreatedAtRef = (0, import_react30.useRef)(null);
   const sessionTokensRef = (0, import_react30.useRef)({ input: 0, output: 0 });
   const profilePromiseRef = (0, import_react30.useRef)(null);
@@ -104841,6 +104859,7 @@ function useReplController({ repoName: repoName2, yolo: yolo2, mentions: mention
           sessionIdRef.current = null;
           sessionCreatedAtRef.current = null;
           coreRunIdRef.current = null;
+          coreCursorRef.current = newRunCursor();
           return;
         case "help":
           notice(formatHelp());
@@ -105152,6 +105171,7 @@ ${list2.map((c) => `  /${c.name}  (${c.scope})${c.description ? `  ${c.descripti
         sessionId: sessionIdRef.current ??= sessions ? sessions.newId() : crypto.randomUUID(),
         cwd: projectRoot,
         runIdRef: coreRunIdRef,
+        cursor: coreCursorRef.current,
         signal: controller.signal,
         emit,
         executor: toolset.executor,
@@ -105270,6 +105290,7 @@ var init_useReplController = __esm({
     init_src();
     init_command_loader();
     init_core_mode();
+    init_core_turn();
     init_slash_commands();
     init_useEventAccumulator();
     gitTopLevel = () => new Promise((resolve2) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spacecode",
-  "version": "2.11.0",
+  "version": "2.12.0",
   "description": "SpaceCode - launch cloud dev environments with AI coding agents",
   "license": "MIT",
   "type": "commonjs",