@brainervirus/workit-opencode 1.3.2 → 2.0.1

package/README.md

@@ -51,14 +51,23 @@ no Workit task, writer or decision is needed merely to run an ordinary command.
 Old action/decision history is preserved. Inspect and reconcile any uncertain
 effect before retrying; removal does not settle or migrate it.
 
+## Upgrade from Workit 1.x
+
+Workit 2.0 removes the managed external-action tool on both OpenCode versions.
+Use native host tools for mutations and `workit_context` for read-only context.
+Existing task and action history remains untouched; reconcile uncertain effects
+before retrying them.
+
 ## Bundle / runtime model
 
 The build bundles the `@opencode-ai/plugin` (V1) and `@opencode/plugin` (V2) SDK surfaces used by the adapters into `dist/plugin.js`, so the published plugin has **no** runtime dependency on either SDK (both stay development/build-only pins). The plugin loads through its real package entry `dist/plugin.js`; only the fourteen method skills ship under `assets/`.
 
 The V2 entry registers the same ten tools with `codemode: false`, the fourteen
-skills and `wk-*` commands (user collisions preserved), question receipts for
-`decision.record`, direct-child subagent lineage with durable dispatch claims,
-and the bootstrap/task/worker context plus compaction injection. Its shell
+skills and up to fourteen `wk-*` commands. Existing user skills and commands
+are preserved; an alias is added only when its Workit skill is registered. It
+also provides question receipts for `decision.record`, direct-child subagent
+lineage with durable dispatch claims, and bootstrap/task/worker context plus
+compaction injection. Its shell
 permission hook adds branch-name policy denials for direct, unquoted literal
 branch-creation forms only. It leaves compliant branches, PR and worktree
 commands, and unsupported shell syntax to OpenCode's native permission rules.

package/assets/skills/workit-implement/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: workit-implement
-description: Use when implementation benefits from bounded delegation or shared checkout coordination
+description: Use when implementing requested code changes in a repository. Follow its rules and host permissions; use Workit tracking and delegation only when continuity or coordination helps.
 ---
 
 # Implement within authority

package/dist/plugin.js

@@ -31346,7 +31346,6 @@ var createV2Lifecycle = (deps) => {
   const dispatches = new Map;
   const inflight = new Map;
   const lifecycleBindings = new Map;
-  const unresolvedTaskLaunches = new Set;
   const now = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
   const readSession = async (sessionID) => {
     try {
@@ -31443,7 +31442,7 @@ var createV2Lifecycle = (deps) => {
     });
     return "prepared";
   };
-  const commitDispatchStart = (coordinator, childID) => {
+  const commitDispatchStart = (coordinator, childID, retainPending = false) => {
     const pending = dispatches.get(coordinator);
     if (!pending)
       return false;
@@ -31463,9 +31462,11 @@ var createV2Lifecycle = (deps) => {
     });
     if (!committed.ok)
       return false;
-    dispatches.delete(coordinator);
-    if (inflight.get(coordinator) === pending.callID)
-      inflight.delete(coordinator);
+    if (!retainPending) {
+      dispatches.delete(coordinator);
+      if (inflight.get(coordinator) === pending.callID)
+        inflight.delete(coordinator);
+    }
     lifecycleBindings.set(childID, {
       parentID: coordinator,
       taskId: pending.taskId,
@@ -31478,32 +31479,32 @@ var createV2Lifecycle = (deps) => {
     const listed = store.listTasks();
     const workspace = store.readWorkspace();
     if (!listed.ok || !workspace.ok || !workspace.data)
-      return;
+      return false;
     const persisted = listed.data.flatMap((task) => task.status === "active" ? task.workers.filter((entry) => entry.id === binding?.workerId || entry.data.session?.kind === "host" && entry.data.session.handle === sessionID).map((entry) => ({ task, entry })) : []);
     const matches = persisted.filter(({ entry }) => entry.data.session?.kind === "host");
     if (binding && matches.length !== 1)
-      return;
+      return false;
     const selected = binding ? persisted.find(({ task, entry }) => task.id === binding.taskId && entry.id === binding.workerId) : matches.length === 1 ? matches[0] : undefined;
     if (!selected)
-      return;
+      return false;
     if (selected.entry.data.session?.kind !== "host")
-      return;
+      return false;
     if (selected.entry.provenance.session?.kind !== "host")
-      return;
+      return false;
     if (!binding && deleted)
-      return;
+      return false;
     if (!deleted) {
       const observed = await readSession(sessionID);
       const observedParent = parentOf(observed);
       if (!observed || !sameWorkspace(root, observed.directory) || !observedParent)
-        return;
+        return false;
       if (!binding) {
         const coordinator = workerCoordinatorFor(selected.task, selected.entry);
         if (!coordinator || observedParent !== coordinator)
-          return;
+          return false;
         parentID = coordinator;
       } else if (observedParent !== parentID)
-        return;
+        return false;
     }
     directChildren.set(sessionID, parentID);
     const core = new WorkitCore(store, {
@@ -31525,34 +31526,51 @@ var createV2Lifecycle = (deps) => {
       observation: { event: state, sessionID }
     });
     if (!result.ok)
-      return;
+      return false;
     lifecycleBindings.set(sessionID, {
       parentID,
       taskId: selected.task.id,
       workerId: selected.entry.id
     });
+    return true;
   };
   const reconcilePending = async (coordinator) => {
     const pending = dispatches.get(coordinator);
-    if (!pending?.childID)
+    if (!pending)
+      return;
+    const task = new TaskStore(root).readTask(pending.taskId);
+    if (task.ok && task.data.workers.find((worker) => worker.id === pending.workerId)?.data.state === "stopped") {
+      dispatches.delete(coordinator);
+      if (inflight.get(coordinator) === pending.callID)
+        inflight.delete(coordinator);
+      return;
+    }
+    if (!pending.childID)
       return;
     const info = await readSession(pending.childID);
-    if (!info || info.id !== pending.childID || !info.outcome)
+    if (!info || info.id !== pending.childID || parentOf(info) !== coordinator || !sameWorkspace(root, info.directory))
       return;
-    await observeLifecycle(pending.childID, coordinator, "stopped", {
+    directChildren.set(info.id, coordinator);
+    const alreadyStarted = lifecycleBindings.get(info.id);
+    if ((!alreadyStarted || alreadyStarted.parentID !== coordinator || alreadyStarted.taskId !== pending.taskId || alreadyStarted.workerId !== pending.workerId) && !commitDispatchStart(coordinator, info.id, Boolean(info.outcome)))
+      return;
+    const terminal = info.outcome !== undefined || pending.completionReport !== undefined;
+    if (!terminal)
+      return;
+    const stopped = await observeLifecycle(info.id, coordinator, "stopped", {
       taskId: pending.taskId,
       workerId: pending.workerId
-    });
-    dispatches.delete(coordinator);
-    if (inflight.get(coordinator) === pending.callID)
-      inflight.delete(coordinator);
+    }, false, info.outcome === "failed" || info.outcome === "interrupted" ? undefined : pending.completionReport);
+    if (stopped) {
+      dispatches.delete(coordinator);
+      if (inflight.get(coordinator) === pending.callID)
+        inflight.delete(coordinator);
+    }
   };
   const coordinatorVeto = (coordinator) => {
     const listed = new TaskStore(root).listTasks();
     if (listed.ok && listed.data.some((task) => task.workers.some((worker) => (worker.data.state === "cancelling" || worker.data.state === "unknown") && worker.provenance.session?.kind === "host" && worker.provenance.session.handle === coordinator)))
       return "recovery_required: a cancelled worker remains uncertain; repeat worker.cancel on the ended worker to confirm its stop, then retry";
-    if (unresolvedTaskLaunches.delete(coordinator))
-      return "recovery_required: a cancelled worker remains uncertain";
     return null;
   };
   const executeBefore = async (event) => {
@@ -31616,34 +31634,50 @@ var createV2Lifecycle = (deps) => {
     const coordinator = event.sessionID;
     const pending = dispatches.get(coordinator);
     const generation = pending?.callID === event.id ? pending : undefined;
+    let started = false;
+    let terminalObserved = false;
+    let terminalObservationRequired = false;
+    let childSession = null;
     if (event.status === "completed") {
       const metadata = record3(event.result.metadata);
       const child = sessionIDOf(metadata.sessionID ?? metadata.sessionId);
+      const output = contentText(event.result.content);
+      const completedOutput = /<subagent\b[^>]*\bstate="completed"/.test(output);
       if (child) {
-        const childSession = await readSession(child);
-        if (parentOf(childSession) === coordinator) {
+        if (generation)
+          generation.childID = child;
+        childSession = await readSession(child);
+        if (parentOf(childSession) === coordinator && sameWorkspace(root, childSession?.directory)) {
           directChildren.set(child, coordinator);
+          const terminal = childSession?.outcome !== undefined || completedOutput;
+          terminalObservationRequired = terminal;
           if (generation)
-            commitDispatchStart(coordinator, child);
+            started = commitDispatchStart(coordinator, child, terminal);
         }
       }
-      const output = contentText(event.result.content);
-      const completedChild = child && /<subagent\b[^>]*\bstate="completed"/.test(output) && lifecycleBindings.has(child) ? child : null;
+      const completedChild = child && (childSession?.outcome !== undefined || completedOutput) && lifecycleBindings.has(child) ? child : null;
       if (completedChild) {
         const binding = lifecycleBindings.get(completedChild);
-        if (binding)
-          await observeLifecycle(completedChild, coordinator, "stopped", binding, false, {
+        if (binding) {
+          const canReportCompletion = completedOutput && childSession?.outcome !== "failed" && childSession?.outcome !== "interrupted";
+          if (canReportCompletion && generation)
+            generation.completionReport = {
+              outcome: "completed",
+              summary: output.trim() || "Native worker completed.",
+              evidenceIds: [],
+              findingIds: []
+            };
+          terminalObserved = canReportCompletion ? await observeLifecycle(completedChild, coordinator, "stopped", binding, false, generation?.completionReport ?? {
             outcome: "completed",
             summary: output.trim() || "Native worker completed.",
             evidenceIds: [],
             findingIds: []
-          });
+          }) : await observeLifecycle(completedChild, coordinator, "stopped", binding);
+        }
       }
-    } else {
-      const message = String(event.error?.message ?? event.error ?? "").toLowerCase();
-      if (generation && /(?:cancel|interrupt|unknown|uncertain)/.test(message))
-        unresolvedTaskLaunches.add(coordinator);
     }
+    if (generation && (event.status === "error" || !started || terminalObservationRequired && !terminalObserved))
+      return;
     if (generation) {
       dispatches.delete(coordinator);
       if (inflight.get(coordinator) === event.id)
@@ -31804,7 +31838,8 @@ var parseFrontmatter = (markdown) => {
 var registerSkills = async (ctx) => {
   const skillsDir = path27.join(assetsRoot(), "skills");
   if (!existsSync14(skillsDir))
-    return;
+    return new Set;
+  const registered = new Set;
   await ctx.skill.transform((editor) => {
     const existing = new Set(editor.list().map((skill) => skill.id));
     for (const id of WORKIT_METHOD_SKILLS) {
@@ -31821,15 +31856,17 @@ var registerSkills = async (ctx) => {
         path: file,
         content: parsed.body
       });
+      registered.add(id);
     }
   });
+  return registered;
 };
-var registerCommands = async (ctx) => {
+var registerCommands = async (ctx, registeredSkills) => {
   const listed = await ctx.command.list();
   const existing = new Set((listed?.data ?? []).map((command) => command.name));
   await ctx.command.transform((editor) => {
     for (const [alias, skill] of Object.entries(WORKIT_SKILL_ALIASES)) {
-      if (existing.has(alias))
+      if (!registeredSkills.has(skill) || existing.has(alias))
         continue;
       editor.add({
         name: alias,
@@ -32061,8 +32098,8 @@ var setup = async (ctx) => {
   await ctx.session.hook("compaction", (event) => {
     injectCompactionContext(root, String(event.sessionID), event.system);
   });
-  await registerSkills(ctx);
-  await registerCommands(ctx);
+  const registeredSkills = await registerSkills(ctx);
+  await registerCommands(ctx, registeredSkills);
   const subscription = new AbortController;
   (async () => {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-opencode",
-  "version": "1.3.2",
+  "version": "2.0.1",
   "private": false,
   "description": "Workit OpenCode plugin — native tools, adaptive policy, and fourteen method skills",
   "keywords": [
@@ -39,7 +39,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@brainervirus/workit-core": "^1.3.2"
+    "@brainervirus/workit-core": "^2.0.1"
   },
   "devDependencies": {
     "@opencode-ai/plugin": "1.18.30",