@brainervirus/workit-core 1.2.0 → 1.3.0

package/src/core/authority.ts

@@ -23,6 +23,7 @@ import {
   type Utc,
 } from "./task-contract";
 import { TaskStore } from "./task-store";
+import { currentWriterOwnsTask } from "./workers";
 
 export type NativeAuthorityContext = {
   now: Utc;
@@ -542,6 +543,27 @@ export const storedDecisionApplicable = (
       verifyDecisionContentAtRoot(store.root, entry.data.binding).ok,
   );
 
+const approvalAuthorityMatches = (
+  store: TaskStore,
+  task: TaskRecord,
+  approval: Provenance,
+  current: Provenance,
+): boolean => {
+  if (approval.kind !== "host_observed" || approval.receipts.length === 0) return false;
+  if (provenanceMatches(approval, current)) return true;
+  const session = current.kind === "host_observed" ? current.session : null;
+  if (!session || session.kind !== "host") return false;
+  const workspace = store.readWorkspace();
+  return (
+    workspace.ok &&
+    workspace.data !== null &&
+    currentWriterOwnsTask(task, workspace.data, {
+      host: session.host,
+      actor: session.handle,
+    })
+  );
+};
+
 const validateAction = (
   store: TaskStore,
   task: TaskRecord,
@@ -574,11 +596,7 @@ const validateAction = (
     return failure("permission_denied", "native reservation authority does not match decision");
   if (decision.response !== "approved")
     return failure("permission_denied", "decision was rejected");
-  if (
-    entry.provenance.kind !== "host_observed" ||
-    entry.provenance.receipts.length === 0 ||
-    !provenanceMatches(entry.provenance, authority.provenance)
-  )
+  if (!approvalAuthorityMatches(store, task, entry.provenance, authority.provenance))
     return failure("permission_denied", "action approval lacks native receipt assurance");
   // Standing auto-approval receipts carry no live question. They authorize
   // only while the referenced workspace rule still covers the operation —
@@ -607,7 +625,12 @@ const validateAction = (
       operation = null;
     }
     const cls = operationAutoClass(operation);
-    if (!cls || !standing.some((receipt) => standingApprovalLive(store.root, receipt, cls)))
+    if (
+      !cls ||
+      !standing.some((receipt) =>
+        standingApprovalLive(store.root, receipt, cls, undefined, decision.binding.approvedContent),
+      )
+    )
       return failure("permission_denied", "standing auto-approval is not live for this operation");
   }
   if (decision.revoked) return failure("permission_denied", "decision is revoked");
@@ -793,7 +816,7 @@ export function settleAction(input: SettleActionInput): Result<Entry<Decision>>
       if (!entry) return failure("not_found", "decision not found");
       if (!authorityDecisionMatches(authority, entry.data))
         return failure("permission_denied", "native settlement authority does not match decision");
-      if (!provenanceMatches(entry.provenance, authority.provenance))
+      if (!approvalAuthorityMatches(input.store, current, entry.provenance, authority.provenance))
         return failure("permission_denied", "native settlement caller does not match approval");
       if (entry.data.purpose !== "action" || entry.data.digest !== decisionDigest(entry.data))
         return failure("permission_denied", "decision binding is invalid");
@@ -931,7 +954,7 @@ export function reconcileAction(input: ReconcileActionInput): Result<Entry<Decis
         return failure("not_found", "decision not found");
       if (
         !authorityDecisionMatches(authority, entry.data) ||
-        !provenanceMatches(entry.provenance, authority.provenance)
+        !approvalAuthorityMatches(input.store, current, entry.provenance, authority.provenance)
       )
         return failure("permission_denied", "native reconciliation caller does not match approval");
       if (

package/src/core/auto-approval.ts

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
+import { readFileSync, realpathSync } from "node:fs";
+import path from "node:path";
 import { resolveWorkspaceFrom, type WorkspaceConfig } from "./workspaces";
 import { configDir } from "./config";
 import { verifyPushIdentity } from "./branch";
@@ -13,9 +14,10 @@ import {
   type Revision,
   type TaskRecord,
 } from "./task-contract";
-import type { TaskStore } from "./task-store";
+import { TaskStore } from "./task-store";
 import type { WorkitCore } from "./task-engine";
 import type { Decision } from "./task-contract";
+import { currentWriterOwnsTask } from "./workers";
 
 /** Action classes auto-approval can cover. Unknown classes never match. */
 export const AUTO_CLASSES = ["branch", "commit", "push", "pr", "merge"] as const;
@@ -100,6 +102,18 @@ export const autoApproves = (root: string, cls: unknown, dir?: string): boolean
 const isStandingReceipt = (value: unknown): value is StandingReceipt =>
   typeof value === "object" && value !== null && (value as { kind?: unknown }).kind === "standing";
 
+const targetOf = (root: string, descriptor: unknown): string | null => {
+  try {
+    const parsed = typeof descriptor === "string" ? JSON.parse(descriptor) : descriptor;
+    const cwd = (parsed as { payload?: { cwd?: unknown } })?.payload?.cwd;
+    if (cwd === undefined) return root;
+    if (typeof cwd !== "string" || !path.isAbsolute(cwd)) return null;
+    return realpathSync(cwd);
+  } catch {
+    return null;
+  }
+};
+
 /**
  * A standing receipt authorizes only while the referenced workspace rule
  * still covers the class. Removing the flag (or narrowing the list) fails
@@ -110,11 +124,14 @@ export const standingApprovalLive = (
   receipt: unknown,
   cls: unknown,
   dir?: string,
+  descriptor?: unknown,
 ): boolean => {
   if (!isStandingReceipt(receipt)) return false;
   if (typeof cls !== "string" || !(AUTO_CLASSES as readonly string[]).includes(cls)) return false;
   if (receipt.class !== cls) return false;
-  const resolved = resolveAutoApproval(root, dir);
+  const target = targetOf(root, descriptor);
+  if (!target) return false;
+  const resolved = resolveAutoApproval(target, dir);
   if (resolved.status !== "on") return false;
   if (resolved.workspace !== receipt.workspace) return false;
   return resolved.classes.includes(cls as AutoClass);
@@ -154,14 +171,10 @@ export const verifyStandingApproval = (
 ): Result<Provenance> => {
   if (task.status !== "active")
     return failure("invalid_transition", "only active tasks can authorize actions");
-  const session = task.intent?.provenance?.session;
-  if (
-    !session ||
-    session.kind !== "host" ||
-    session.host !== caller.host ||
-    session.handle !== caller.actor
-  )
-    return failure("permission_denied", "standing approval requires the lead session");
+  const workspace = new TaskStore(root).readWorkspace();
+  if (!workspace.ok) return workspace as Result<never>;
+  if (!workspace.data || !currentWriterOwnsTask(task, workspace.data, caller))
+    return failure("permission_denied", "standing approval requires the current writer session");
   const standing = binding.standing;
   if (!standing || typeof standing.workspace !== "string" || typeof standing.class !== "string")
     return failure("invalid_input", "standing approval needs a workspace and class");
@@ -177,7 +190,9 @@ export const verifyStandingApproval = (
   const cls = operationAutoClass(operation);
   if (!cls || cls !== standing.class)
     return failure("permission_denied", "standing approval does not cover this operation");
-  const resolved = resolveAutoApproval(root);
+  const target = targetOf(root, binding.approvedContent);
+  if (!target) return failure("permission_denied", "standing action target is invalid");
+  const resolved = resolveAutoApproval(target);
   if (
     resolved.status !== "on" ||
     resolved.workspace !== standing.workspace ||
@@ -185,7 +200,7 @@ export const verifyStandingApproval = (
   )
     return failure("permission_denied", "standing auto-approval is not live for this operation");
   if (cls === "push") {
-    const workspace = resolveWorkspaceFrom(root, configDir());
+    const workspace = resolveWorkspaceFrom(target, configDir());
     const provider = workspace?.vcs?.provider;
     const account = resolved.account;
     if (!provider || !account)
@@ -193,7 +208,7 @@ export const verifyStandingApproval = (
         "permission_denied",
         "auto-push requires a workspace provider and area account",
       );
-    const identity = verifyPushIdentity(root, provider, account);
+    const identity = verifyPushIdentity(target, provider, account);
     if (!identity.ok) return failure("permission_denied", identity.error);
   }
   return success(null, null, {
@@ -201,7 +216,7 @@ export const verifyStandingApproval = (
     host: caller.host,
     session: { kind: "host", host: caller.host, handle: caller.actor },
     workerId: null,
-    receipts: [standingReceiptFor(root, standing.workspace, cls)],
+    receipts: [standingReceiptFor(target, standing.workspace, cls)],
   } as Provenance);
 };
 
@@ -232,30 +247,26 @@ export const standingAutoApplies = (
   actor: string,
   operation: string,
 ): StandingMatch | null => {
-  let descriptor: { operation?: unknown };
+  let descriptor: { operation?: unknown; payload?: unknown };
   try {
-    descriptor = JSON.parse(operation) as { operation?: unknown };
+    descriptor = JSON.parse(operation) as { operation?: unknown; payload?: unknown };
   } catch {
     return null;
   }
   const cls = operationAutoClass(descriptor.operation);
-  if (!cls || !autoApproves(store.root, cls)) return null;
+  const target = targetOf(store.root, descriptor);
+  if (!cls || !target || !autoApproves(target, cls)) return null;
   const listed = store.listTasks();
   const workspace = store.readWorkspace();
   if (!listed.ok || !workspace.ok || !workspace.data) return null;
-  const matches = listed.data.filter(
-    (task) =>
-      task.status === "active" &&
-      task.workspaceId === workspace.data!.id &&
-      task.intent?.provenance?.session?.kind === "host" &&
-      (task.intent.provenance.session as { host?: unknown; handle?: unknown }).host === host &&
-      (task.intent.provenance.session as { host?: unknown; handle?: unknown }).handle === actor,
+  const task = listed.data.find((task) =>
+    currentWriterOwnsTask(task, workspace.data!, { host, actor }),
   );
-  if (matches.length !== 1) return null;
-  const resolved = resolveAutoApproval(store.root);
+  if (!task) return null;
+  const resolved = resolveAutoApproval(target);
   if (resolved.status !== "on") return null;
   return {
-    task: matches[0],
+    task,
     workspaceId: workspace.data.id,
     workspaceRevision: workspace.data.revision,
     cls,
@@ -279,18 +290,19 @@ export const standingAutoBinding = (
   actor: string,
   operation: string,
 ): StandingAutoBinding | null => {
-  let descriptor: { operation?: unknown };
+  let descriptor: { operation?: unknown; payload?: unknown };
   try {
-    descriptor = JSON.parse(operation) as { operation?: unknown };
+    descriptor = JSON.parse(operation) as { operation?: unknown; payload?: unknown };
   } catch {
     return null;
   }
   const cls = operationAutoClass(descriptor.operation);
-  if (!cls || !autoApproves(store.root, cls)) return null;
+  const target = targetOf(store.root, descriptor);
+  if (!cls || !target || !autoApproves(target, cls)) return null;
   const applies = standingAutoApplies(store, host, actor, operation);
   if (!applies) return null;
   const { task } = applies;
-  const resolved = resolveAutoApproval(store.root);
+  const resolved = resolveAutoApproval(target);
   if (resolved.status !== "on") return null;
   const presented =
     `Workit decision: action — auto-approved ${String(descriptor.operation)} ` +