@brainervirus/workit-opencode 8.30.0 → 8.31.1

package/dist/plugin.js

@@ -14149,6 +14149,18 @@ function diffHash(cwd, base, head) {
   }
   return `sha256:${hash.digest("hex")}`;
 }
+function cleanRebase(cwd, range) {
+  if (!Object.values(range).every(safeRef2))
+    return false;
+  const fromFork = git4(cwd, ["merge-base", range.fromBase, range.from]);
+  const toFork = git4(cwd, ["merge-base", range.toBase, range.to]);
+  if (!fromFork || !toFork || fromFork === toFork)
+    return false;
+  const merged = gitRun2(cwd, ["merge-tree", "--write-tree", "--no-messages", `--merge-base=${fromFork}`, toFork, range.from], GIT_TIMEOUTS.worktree);
+  const tree = merged.ok ? merged.stdout.split(`
+`)[0]?.trim() : null;
+  return Boolean(tree) && tree === git4(cwd, ["rev-parse", "--verify", "-q", `${range.to}^{tree}`]);
+}
 function storeRoot(cwd) {
   const location = resolveStore(path16.resolve(cwd));
   if (location instanceof Error)
@@ -14812,23 +14824,24 @@ function checkVerdicts(cwd, branch, ledgerRows) {
     return drift;
   };
   const exactCache = new Map;
-  const exactCarry = (row) => {
-    if (FAILING.has(String(row.result)))
-      return true;
+  const exactMatch = (row) => {
     let exact = exactCache.get(row);
     if (exact === undefined) {
       const toBase = row.base ?? fallbackBase;
       const toBaseSha = toBase ? resolveCommit(cwd, toBase) : null;
       const fromBase = row.baseSha ?? toBaseSha;
-      exact = Boolean(row.head && head && toBaseSha && fromBase && sameOwnChange(cwd, { from: row.head, to: head, fromBase, toBase: toBaseSha }));
+      const range = row.head && head && toBaseSha && fromBase ? { from: row.head, to: head, fromBase, toBase: toBaseSha } : null;
+      exact = !range ? null : sameOwnChange(cwd, range) ? "same" : cleanRebase(cwd, range) ? "rebase" : null;
       exactCache.set(row, exact);
     }
     return exact;
   };
+  const exactCarry = (row) => FAILING.has(String(row.result)) || exactMatch(row) !== null;
   const keyBasis = (row) => {
     const basis = verdictBasis(row, { head, ...keyFor(row.base ?? fallbackBase) });
     return basis === "carried" && !exactCarry(row) ? "stale" : basis;
   };
+  const rebaseNote = (row) => row.head && head && row.head !== head && !FAILING.has(String(row.result)) && keyBasis(row) === "carried" && exactMatch(row) === "rebase" ? { rule: "rebase", since: row.head, files: [] } : null;
   const restacked = (row) => restackCarries(FAILING.has(String(row.result)) ? null : cwd, rows, branch, row.head, head);
   const carryOf = (row) => {
     if (keyBasis(row) !== "stale")
@@ -14906,7 +14919,7 @@ function checkVerdicts(cwd, branch, ledgerRows) {
       independent: independence.length === 0,
       accepted: reasons.length === 0,
       reasons,
-      carry: basis === "carried" ? carryOf(row) : null,
+      carry: basis === "carried" ? rebaseNote(row) ?? carryOf(row) : null,
       verdict: row
     });
     if (reasons.length === 0) {
@@ -25721,6 +25734,22 @@ var judgeVerdictText = (root, session, workerContext) => {
   });
   return `If this session verifies or reviews a candidate, record its verdict with exactly this command (pick the result and kind, live when you drove the real surface, name the candidate branch if it differs, say what you ran): \`${line}\`. Your shell already acts as your own Workit session ${childSessionId(session.parentID ?? "", session.id)}: pass no --session or --token, and never set WORKIT_SESSION_ID by hand.`;
 };
+var injectModelSwitch = (root, session, directChildren, system) => {
+  if (!session || !sameWorkspace(root, session.directory))
+    return;
+  const contract = session.parentID ? workerContextFor(root, session.id, session.parentID, directChildren) : getWorkitBootstrap();
+  const taskContext = compactContextFor(root, session.id);
+  const parts = [
+    contract,
+    taskContext && `<workit-task-context>${taskContext}</workit-task-context>`
+  ].filter(Boolean);
+  if (parts.length === 0)
+    return;
+  system.push(textPart(`<workit-model-switch>
+${parts.join(`
+`)}
+</workit-model-switch>`));
+};
 var injectHistoryOffer = (root, session, offeredSessions, system) => {
   if (!session || session.parentID !== undefined || !sameWorkspace(root, session.directory) || offeredSessions.has(session.id))
     return;
@@ -25804,6 +25833,60 @@ var childDenial = (identity) => `OpenCode child session has no validated Workit
 
 // packages/workit-opencode/src/v2/shell.ts
 import path44 from "node:path";
+
+// packages/workit-core/src/hooks/repeat-failure.ts
+import { createHash as createHash18 } from "node:crypto";
+var SAME_CALL_FAILED = "Same call failed twice:";
+var MAX_SESSIONS = 256;
+var stable = (value) => JSON.stringify(value, (_key, entry) => entry && typeof entry === "object" && !Array.isArray(entry) ? Object.fromEntries(Object.entries(entry).toSorted(([a], [b]) => a.localeCompare(b))) : entry) ?? "null";
+var hashOf = (call) => createHash18("sha256").update(call).digest("hex").slice(0, 32);
+var record3 = (memo, sessionId, call, failed, next) => {
+  const previous = memo.get(sessionId);
+  memo.delete(sessionId);
+  if (!failed)
+    return null;
+  const hash = hashOf(call);
+  memo.set(sessionId, hash);
+  if (memo.size > MAX_SESSIONS)
+    memo.delete(memo.keys().next().value);
+  return previous === hash && next ? `${SAME_CALL_FAILED} ${next}` : null;
+};
+var isFailure = (result) => result !== null && typeof result === "object" && result.ok === false && typeof result.error === "string";
+var correctedPayload = (tool, result) => {
+  const example = /Example: (\{.*\})\s*$/.exec(result.error)?.[1];
+  if (example)
+    return `${tool} ${example}`;
+  const guidance = result.details?.guidance;
+  return typeof guidance === "string" && guidance ? guidance : null;
+};
+var escalateToolFailure = (memo, sessionId, tool, input, result) => {
+  const failed = isFailure(result);
+  const line = record3(memo, sessionId, `tool\x00${tool}\x00${stable(input)}`, failed, failed ? correctedPayload(tool, result) : null);
+  return line && failed ? { ...result, error: `${result.error}
+${line}` } : result;
+};
+var WORKIT_COMMAND = /^\s*(?:[A-Za-z_][A-Za-z0-9_]*=\S*\s+)*workit\s/;
+var unblockOf = (output) => {
+  const human = /^\s*unblock: (.+)$/m.exec(output)?.[1];
+  if (human)
+    return human.trim();
+  const json = /"unblock":("(?:[^"\\]|\\.)*")/.exec(output)?.[1];
+  if (!json)
+    return null;
+  try {
+    return JSON.parse(json);
+  } catch {
+    return null;
+  }
+};
+var repeatedCliFailure = (memo, sessionId, command, output) => {
+  if (!WORKIT_COMMAND.test(command))
+    return null;
+  const failed = /^workit: /m.test(output) || /"ok":\s*false/.test(output);
+  return record3(memo, sessionId, `cli\x00${command.trim()}`, failed, failed ? unblockOf(output) : null);
+};
+
+// packages/workit-opencode/src/v2/shell.ts
 var commandOf = (input) => {
   if (input === null || typeof input !== "object")
     return null;
@@ -25855,7 +25938,12 @@ var observeShellBefore = (root, event, workdirs) => {
     noteRawCommit(input, shell.command, callKey(String(event.id), shell.command));
   } catch {}
 };
-var observeShellResult = (root, event) => {
+var outputText = (content) => typeof content === "string" ? content : Array.isArray(content) ? content.map((part) => typeof part.text === "string" ? part.text : "").join(`
+`) : "";
+var appendText = (result, text) => typeof result.content === "string" ? { ...result, content: `${result.content}
+
+${text}` } : Array.isArray(result.content) ? { ...result, content: [...result.content, { type: "text", text }] } : result;
+var observeShellResult = (root, event, failures = new Map) => {
   try {
     if (event.tool !== "shell" || event.status !== "completed")
       return;
@@ -25866,17 +25954,14 @@ var observeShellResult = (root, event) => {
     rawGitPost(input, shell.command, callKey(String(event.id), shell.command));
     const nudge = shellNudge(input, shell.command);
     const result = event.result;
-    if (nudge.kind !== "context" || !result)
+    if (!result)
       return;
-    if (typeof result.content === "string")
-      event.result = { ...result, content: `${result.content}
+    const repeated = repeatedCliFailure(failures, String(event.sessionID), shell.command, outputText(result.content));
+    const extra = [nudge.kind === "context" ? nudge.text : null, repeated].filter((text) => text !== null);
+    if (extra.length > 0)
+      event.result = appendText(result, extra.join(`
 
-${nudge.text}` };
-    else if (Array.isArray(result.content))
-      event.result = {
-        ...result,
-        content: [...result.content, { type: "text", text: nudge.text }]
-      };
+`));
   } catch {}
 };
 
@@ -25968,15 +26053,15 @@ var injectSkillNudge = (root, session, messages, system) => {
 };
 
 // packages/workit-opencode/src/v2/stop.ts
-var record3 = (value) => typeof value === "object" && value !== null ? value : {};
+var record4 = (value) => typeof value === "object" && value !== null ? value : {};
 var lastAssistantText = (messages) => {
   for (const message of messages.toReversed()) {
-    if (record3(message).type !== "assistant")
+    if (record4(message).type !== "assistant")
       continue;
-    const content = record3(message).content;
+    const content = record4(message).content;
     if (!Array.isArray(content))
       return null;
-    const text = content.filter((part) => record3(part).type === "text" && typeof record3(part).text === "string").map((part) => record3(part).text).join(`
+    const text = content.filter((part) => record4(part).type === "text" && typeof record4(part).text === "string").map((part) => record4(part).text).join(`
 `);
     return text || null;
   }
@@ -26147,6 +26232,28 @@ var pluginSourceFiles = [
   ])
 ].filter((file) => existsSync16(file)).toSorted();
 
+// packages/workit-core/src/hooks/model-switch.ts
+var MAX_SESSIONS2 = 256;
+var modelSwitched = (models, sessionId, model) => {
+  if (!model)
+    return false;
+  const previous = models.get(sessionId);
+  models.delete(sessionId);
+  models.set(sessionId, model);
+  if (models.size > MAX_SESSIONS2)
+    models.delete(models.keys().next().value);
+  return previous !== undefined && previous !== model;
+};
+var modelKey = (model) => {
+  if (model === null || typeof model !== "object")
+    return null;
+  const { id, providerID, provider } = model;
+  if (typeof id !== "string" || !id)
+    return null;
+  const source = typeof providerID === "string" ? providerID : provider;
+  return typeof source === "string" && source ? `${source}/${id}` : id;
+};
+
 // packages/workit-opencode/src/v2/plugin.ts
 var sessionFacts = async (ctx, sessionID) => {
   try {
@@ -26185,6 +26292,8 @@ var setup = async (ctx) => {
   const sourceMarker = markSourcesLoaded(pluginSourceFiles);
   let staleSourcesWarned = false;
   const historyOfferSessions = new Set;
+  const sessionModels = new Map;
+  const failureMemo = new Map;
   const lifecycle = createV2Lifecycle({
     root,
     getSession: async (sessionID) => {
@@ -26223,9 +26332,10 @@ var setup = async (ctx) => {
         input: spec.input,
         options: { codemode: false },
         execute: async (input, tool) => {
+          const respond = (value) => resultContent(escalateToolFailure(failureMemo, String(tool.sessionID), spec.name, input, value));
           const session = await sessionFacts(ctx, tool.sessionID);
           if (session === null || !sameWorkspace(root, session.directory))
-            return resultContent(failure2("permission_denied", "OpenCode session location does not match the plugin checkout"));
+            return respond(failure2("permission_denied", "OpenCode session location does not match the plugin checkout"));
           if (spec.name === "workit_context")
             return {
               content: await contextTool.execute(input, { directory: root, sessionID: session.id })
@@ -26239,19 +26349,19 @@ var setup = async (ctx) => {
             const directChild = lead !== null && lead.parentID === undefined && sameWorkspace(root, lead.directory);
             const inspecting = childMayInspect(family, input);
             if (!directChild || family === null || !(inspecting || childMayRecord(family, input)))
-              return resultContent(failure2("permission_denied", childDenial(identity)));
+              return respond(failure2("permission_denied", childDenial(identity)));
             if (inspecting)
-              return resultContent(runFamily(family, input, { ...session, id: identity }, store, null, true));
+              return respond(runFamily(family, input, { ...session, id: identity }, store, null, true));
             if (childTaskMissing(store, input))
-              return resultContent(failure2("not_found", "no task for this branch yet: the lead starts one (workit_task start) before a child records on it, or pass taskId"));
-            return resultContent(runFamily(family, input, { ...session, id: identity }, store, null));
+              return respond(failure2("not_found", "no task for this branch yet: the lead starts one (workit_task start) before a child records on it, or pass taskId"));
+            return respond(runFamily(family, input, { ...session, id: identity }, store, null));
           }
           if (family !== null)
-            return resultContent(runFamily(family, input, session, store, workerId));
+            return respond(runFamily(family, input, session, store, workerId));
           if (spec.name === "workit_init_apply") {
             return { content: executeInitApply(input, root, initApplyRuntime) };
           }
-          return resultContent(failure2("not_found", `unknown Workit tool ${spec.name}`));
+          return respond(failure2("not_found", `unknown Workit tool ${spec.name}`));
         }
       });
     }
@@ -26286,7 +26396,7 @@ var setup = async (ctx) => {
   await ctx.tool.hook("execute.after", async (event) => {
     if (event.tool === "shell") {
       settleShellCall(pendingShells, { sessionID: String(event.sessionID), input: event.input });
-      return observeShellResult(root, event);
+      return observeShellResult(root, event, failureMemo);
     }
     if (event.tool !== "subagent")
       return;
@@ -26307,6 +26417,8 @@ var setup = async (ctx) => {
     injectHistoryOffer(root, session, historyOfferSessions, event.system);
     if (session)
       injectSkillNudge(root, session, event.messages, event.system);
+    if (modelSwitched(sessionModels, String(event.sessionID), modelKey(event.model)))
+      injectModelSwitch(root, session, lifecycle.directChildren, event.system);
     if (!staleSourcesWarned) {
       const changed = changedSourcesSinceLoad(sourceMarker);
       if (changed.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-opencode",
-  "version": "8.30.0",
+  "version": "8.31.1",
   "private": false,
   "description": "Workit OpenCode plugin — native tools, adaptive policy, and sixteen method skills",
   "keywords": [
@@ -39,7 +39,7 @@
     "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
-    "@brainervirus/workit-core": "^8.30.0",
+    "@brainervirus/workit-core": "^8.31.1",
     "@opencode/plugin": "2.0.18"
   },
   "engines": {