@brainervirus/workit-opencode 2.0.0 → 2.0.2

package/README.md

@@ -43,7 +43,7 @@ plugin is a self-contained Node bundle; its default export is a dual entry
 
 - **Receipts** — native `question` answers are purpose-bound, session-bound, fresh, and one-use; unrelated questions fail closed.
 - **Delegation** — native `task` workers are direct-child-only; nested or uncertain lineage is denied (`delegation_lineage_denied`).
-- **Continuity** — compact task context is injected once on session start and once after compaction; unobservable shell surfaces are labeled `agent_guided`.
+- **Continuity** — compact task context carries the newest decisions and bounded redacted choice summaries, injected once on session start and once after compaction; unobservable shell surfaces are labeled `agent_guided`.
 
 Workit does not register `workit_external_action` on either OpenCode version.
 Use native tools for mutations under the host permissions and target conventions;
@@ -63,9 +63,11 @@ before retrying them.
 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
@@ -22,6 +22,14 @@ request, and a timeout is not proof that a worker stopped.
    until process exit or explicit recovery.
 4. Reconcile helper reports and run the checks appropriate to the requested
    outcome. If delegation is unavailable, continue inline when useful.
+5. Before a cross-repo mutation, resolve the actual checkout, branch and remote
+   from the request and current context. Ask only if competing plausible targets
+   remain unresolved. Branch, commit, direct push, PR-ready, merge and release
+   are distinct endpoints; perform only the authorized one under target rules.
+   Before saying done, reconcile every named deliverable against that checkout
+   and verify the requested result. For a push, observe the destination remote
+   ref and confirm it contains the delivered commit; report drift or missing
+   items as blockers instead of treating local success as remote delivery.
 
 Do not edit Workit metadata directly, create nested helper trees, widen paths, or
 create a second lifecycle. Read-only investigation and bounded reports do not

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

@@ -18,7 +18,11 @@ request. Preserve continuity when it helps; do not manufacture task mutations.
 3. For a separate request, do not silently resume an old objective. Park a
    concise checkpoint only when substantial work needs to continue later. Start
    a distinct tracked record only if the new work benefits from continuity,
-   dependencies, coordination, or durable decisions.
+   dependencies, coordination, or durable decisions. For work spanning repos,
+   checkpoint each unfinished item with its checkout, branch, requested
+   deliverables, and delivery endpoint. Keep explicitly held items parked with
+   their resume condition until the user resumes them. A conversational
+   checkpoint is sufficient when no task record is needed.
 4. Before resuming a named tracked task, reconcile its checkout, branch, dirty
    state, current policy, stale evidence, uncertain effects, and ownership. Do
    not change branches, stash, fetch large histories, or seize ownership just

package/dist/plugin.js

@@ -12560,7 +12560,8 @@ let imported decisions grant authority. Never turn a host deny into allow or
 claim enforcement/evidence a host cannot provide. A precise request with settled
 constraints does not need an interview. Present genuine unresolved options with
 evidence and a recommendation, then continue toward the requested delivery
-endpoint: investigation, implementation, PR/MR-ready, merge, or release. Run
+endpoint: investigation, implementation, branch/commit/push, PR/MR-ready,
+merge, or release. Run
 applicable checks and safe repairs without repeated continuation questions;
 stop for missing host authority, a new consequential choice, a conflicting edit,
 or an unresolved blocker. A tracked record may close when actual evidence
@@ -12572,6 +12573,12 @@ confirm the stop. Preserve unresolved requirements, gaps, and uncertain workers.
 When context changes, distinguish a quick question, same-task adjustment, and
 separate request. Answer a quick question without pausing/resuming task state;
 park a concise checkpoint only when substantial work needs to continue later.
+For work spanning repositories, bind each unfinished item to its actual checkout,
+branch, requested deliverables, and delivery endpoint. Preserve held items with
+an explicit resume condition. Resolve competing plausible targets before a
+mutation; ask only when available context cannot settle that consequential choice.
+Before reporting delivery, reconcile every requested item and observe the actual
+target result; a local commit alone is not evidence of a requested remote push.
 
 Skill routing: slash aliases /wk-* load on demand. Use workit-steer for a
 substantial interruption or change of direction, workit-deslop when relevant
@@ -12618,6 +12625,13 @@ var compactText = (value, limit) => value === null ? null : value.replace(privat
   return `${match.slice(0, space)} <redacted>`;
 }).slice(0, limit);
 var compactBytes = (value) => new TextEncoder().encode(value).byteLength;
+var compactTimestamp = (value) => `${value.slice(0, 19)}.${value.slice(20, -1).padEnd(9, "0")}`;
+var compactDecisionChoice = (entry) => {
+  const stated = entry.data.binding.statedChoice?.text;
+  const approved = entry.data.response === "approved" ? entry.data.binding.approvedContent : "";
+  const source = stated?.trim() || approved.trim() || null;
+  return compactText(source, COMPACT_TEXT_BYTES);
+};
 var compactReference = (ref) => {
   if (ref.kind === "file")
     return {
@@ -12633,11 +12647,18 @@ var compactReference = (ref) => {
   return { kind: ref.kind };
 };
 function compactTaskContext(view) {
-  const decisions = view.task.decisions.slice().sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0).slice(0, COMPACT_MAX_ITEMS).map((entry) => ({
+  const decisions = view.task.decisions.slice().sort((left, right) => {
+    const leftAt = compactTimestamp(left.recordedAt);
+    const rightAt = compactTimestamp(right.recordedAt);
+    if (leftAt !== rightAt)
+      return leftAt > rightAt ? -1 : 1;
+    return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
+  }).slice(0, COMPACT_MAX_ITEMS).map((entry) => ({
     id: entry.id,
     purpose: entry.data.purpose,
     status: entry.data.response,
     digest: entry.data.digest,
+    choice: compactDecisionChoice(entry) || `task.inspect taskId=${view.task.id} view=full; decision=${entry.id}`,
     references: entry.data.binding.contentRefs.slice(0, 1).map(compactReference)
   }));
   const methods = view.task.policy ? selectMethods(view.task.policy, view.capabilities).map((method) => ({
@@ -31346,7 +31367,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 +31463,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 +31483,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 +31500,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 +31547,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 +31655,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 +31859,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 +31877,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 +32119,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": "2.0.0",
+  "version": "2.0.2",
   "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": "^2.0.0"
+    "@brainervirus/workit-core": "^2.0.2"
   },
   "devDependencies": {
     "@opencode-ai/plugin": "1.18.30",