@brainervirus/workit-opencode 8.15.1 → 8.16.1

package/dist/plugin.js

@@ -16086,6 +16086,54 @@ function evaluateClosure(requestedOutcome, view) {
     requirementIds: evaluations.map((item) => item.requirementId)
   });
 }
+var BRIEF_TEXT = 250;
+var BRIEF_BLOCKERS = 3;
+var BRIEF_OPEN = 8;
+var clip = (value) => {
+  const fits = (text) => Buffer.byteLength(JSON.stringify(text)) <= BRIEF_TEXT;
+  if (fits(value))
+    return value;
+  let length = Math.min(value.length, BRIEF_TEXT);
+  while (length > 0 && !fits(`${value.slice(0, length)}…`))
+    length -= 1;
+  return `${value.slice(0, length)}…`;
+};
+function boundTaskSummary(summary) {
+  const rules = new Map((summary.policy?.requirements ?? []).map((item) => [item.id, item]));
+  const unmet = summary.requirements.filter((item) => item.status === "unsatisfied" || item.status === "unavailable");
+  const { progress, closure } = summary;
+  const next = progress.nextAction;
+  const open = unmet.slice(0, BRIEF_OPEN).map((item) => ({
+    dimension: rules.get(item.requirementId)?.dimension ?? "verification",
+    before: rules.get(item.requirementId)?.before ?? "close",
+    status: item.status
+  }));
+  const brief = {
+    id: summary.id,
+    revision: summary.revision,
+    workspaceRevision: summary.workspaceRevision,
+    updatedAt: summary.updatedAt,
+    objective: clip(summary.objective),
+    status: summary.status,
+    closure: closure && {
+      outcome: closure.outcome,
+      at: closure.at,
+      summary: clip(closure.summary)
+    },
+    progress: {
+      summary: clip(progress.summary),
+      nextAction: next && clip(next),
+      blockers: progress.blockers.slice(0, BRIEF_BLOCKERS).map((item) => ({
+        reason: clip(item.reason),
+        dependentAction: clip(item.dependentAction)
+      }))
+    },
+    requirements: { total: summary.requirements.length, unmet: unmet.length, open },
+    truncated: false
+  };
+  brief.truncated = JSON.stringify(brief).includes("…") || progress.blockers.length > BRIEF_BLOCKERS || unmet.length > BRIEF_OPEN;
+  return brief;
+}
 
 // packages/workit-core/src/core/methods.ts
 var METHODS = {
@@ -19514,6 +19562,15 @@ class WorkitCore {
     if (!parsed.ok)
       return parsed;
     const input = parsed.data;
+    if (this.context.readOnlyChild) {
+      if (input.action !== "inspect")
+        return failure2("permission_denied", "child sessions can only inspect the task summary");
+      const task = this.store.readTask(input.taskId);
+      if (!task.ok)
+        return task;
+      const summary = this.summary(task.data);
+      return summary.ok ? { ...summary, data: boundTaskSummary(summary.data) } : summary;
+    }
     if ((this.context.workerId ?? null) !== null) {
       if (input.action !== "inspect" && input.action !== "list")
         return failure2("permission_denied", "helpers cannot control task lifecycle or scope");
@@ -24176,13 +24233,56 @@ var createV2Lifecycle = (deps) => {
   const unboundLaunch = (coordinator) => {
     const store = new TaskStore(root);
     const current = currentTaskId(store);
-    const base = current === null ? 'recovery_required: this branch has no Workit task yet; start it (workit_task start, or `workit task start "<objective>"`), then assign a worker on it with workit_worker before launching a native task' : "recovery_required: no assigned Workit worker is attributable to this coordinator on the current branch's task; assign one with workit_worker before launching a native task";
+    const base = current === null ? 'recovery_required: this branch has no Workit task yet; start it (workit_task start, or `workit task start "<objective>"`), then assign a worker on it with workit_worker before launching a native task' : "recovery_required: no assigned Workit worker is attributable to this coordinator on the current branch's task (worker assignments are branch-scoped: they follow the task of the branch checked out when the launch happens); assign one with workit_worker on this branch's task before launching a native task";
     const listed = store.listTasks();
     if (!listed.ok)
       return base;
     const stale = listed.data.flatMap((task) => task.status === "active" && task.id !== current ? task.workers.filter((worker) => (worker.data.state === "assigned" || worker.data.state === "running") && worker.provenance.session?.kind === "host" && worker.provenance.session.handle === coordinator).map((worker) => `workit_worker {"action":"cancel","taskId":"${task.id}","workerId":"${worker.id}","reason":"stale worker from another branch"}`) : []);
     return stale.length > 0 ? `${base}. Workers of this coordinator are still open on other tasks; cancel any that are stale: ${stale.join("; ")}` : base;
   };
+  const rebindStaleWorker = (coordinator, current, stale) => {
+    if (stale.length !== 1)
+      return false;
+    const { task: from, entry } = stale[0];
+    const store = new TaskStore(root);
+    const target = store.readTask(current);
+    if (!target.ok || target.data.status !== "active")
+      return false;
+    const core = new WorkitCore(store, {
+      root,
+      caller: { host: "opencode", actor: coordinator },
+      capabilities: [],
+      constraints: [],
+      now
+    });
+    const assigned = core.worker({
+      schemaVersion: 1,
+      action: "assign",
+      taskId: current,
+      assignment: entry.data.assignment
+    });
+    if (!assigned.ok)
+      return false;
+    const cancelled = core.worker({
+      schemaVersion: 1,
+      action: "cancel",
+      taskId: from.id,
+      workerId: entry.id,
+      reason: `rebound to task ${current} (worker ${assigned.data.id}) after a branch switch`
+    });
+    const latest = store.readTask(current);
+    if (cancelled.ok && latest.ok)
+      core.task({
+        schemaVersion: 1,
+        action: "progress",
+        taskId: current,
+        progress: {
+          ...latest.data.progress,
+          summary: `${latest.data.progress.summary} (worker ${assigned.data.id} rebound from task ${from.id} after a branch switch)`
+        }
+      });
+    return cancelled.ok;
+  };
   const prepareDispatch = (coordinator, callID) => {
     if (dispatches.has(coordinator))
       return "unsettled";
@@ -24196,7 +24296,16 @@ var createV2Lifecycle = (deps) => {
       return "unmanaged";
     const eligible = managed.flatMap((task) => task.workers.filter((entry) => entry.data.state === "assigned" && entry.data.session === null && entry.provenance.session?.kind === "host" && entry.provenance.session.host === "opencode" && entry.provenance.session.handle === coordinator).map((entry) => ({ task, entry })));
     const current = currentTaskId(store);
-    const next = oldest(eligible.filter((item) => item.task.id === current));
+    let next = oldest(eligible.filter((item) => item.task.id === current));
+    if (!next && current !== null) {
+      const stale = eligible.filter((item) => item.task.id !== current);
+      if (rebindStaleWorker(coordinator, current, stale)) {
+        const refreshed = store.readTask(current);
+        const rebound = refreshed.ok ? refreshed.data.workers.filter((entry) => entry.data.state === "assigned" && entry.data.session === null && entry.provenance.session?.kind === "host" && entry.provenance.session.handle === coordinator) : [];
+        if (refreshed.ok && rebound.length > 0)
+          next = oldest(rebound.map((entry) => ({ task: refreshed.data, entry })));
+      }
+    }
     if (!next)
       return "unbound";
     dispatches.set(coordinator, {
@@ -24659,13 +24768,14 @@ var childMayRecord = (family, input) => {
   const action = fields(input).action;
   return family !== null && typeof action === "string" && CHILD_RECORDS[family]?.has(action) === true;
 };
+var childMayInspect = (family, input) => family === "task" && fields(input).action === "inspect";
 var childTaskMissing = (store, input) => {
   if (fields(input).taskId !== undefined)
     return false;
   const report = store.keyReport();
   return !report.ok || report.data.bound.length === 0;
 };
-var childDenial = (identity) => `OpenCode child session has no validated Workit worker: as ${identity} it may only record evidence or findings (workit_evidence/workit_finding action "record") on an existing task; for anything else the lead assigns it a worker with workit_worker before launching it`;
+var childDenial = (identity) => `OpenCode child session has no validated Workit worker: as ${identity} it may only inspect the task summary (workit_task action "inspect") or record evidence or findings (workit_evidence/workit_finding action "record") on an existing task; for anything else the lead assigns it a worker with workit_worker before launching it`;
 
 // packages/workit-opencode/src/v2/shell.ts
 import path38 from "node:path";
@@ -25041,7 +25151,7 @@ var setup = async (ctx) => {
     }
   });
   const contextTool = createContextTool();
-  const runFamily = (family, input, session, store, workerId) => {
+  const runFamily = (family, input, session, store, workerId, readOnlyChild = false) => {
     const parsed = parseAdvertisedOperation(family, input, "opencode");
     if (!parsed.ok)
       return parsed;
@@ -25052,6 +25162,7 @@ var setup = async (ctx) => {
       constraints: [],
       now: () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z"),
       workerId,
+      ...readOnlyChild ? { readOnlyChild } : {},
       nativeWorker: nativeWorkerFor(lifecycle.directChildren, session.id)
     });
     const run = core[family];
@@ -25079,8 +25190,11 @@ var setup = async (ctx) => {
             const identity = childSessionId(session.parentID, session.id);
             const lead = await sessionFacts(ctx, session.parentID);
             const directChild = lead !== null && lead.parentID === undefined && sameWorkspace(root, lead.directory);
-            if (!directChild || family === null || !childMayRecord(family, input))
+            const inspecting = childMayInspect(family, input);
+            if (!directChild || family === null || !(inspecting || childMayRecord(family, input)))
               return resultContent(failure2("permission_denied", childDenial(identity)));
+            if (inspecting)
+              return resultContent(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));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-opencode",
-  "version": "8.15.1",
+  "version": "8.16.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.15.1",
+    "@brainervirus/workit-core": "^8.16.1",
     "@opencode/plugin": "2.0.18"
   },
   "engines": {