@brainervirus/workit-opencode 6.0.0 → 7.0.0

package/dist/plugin.js

@@ -4,9 +4,9 @@ function define(plugin) {
 }
 
 // packages/workit-core/src/core.ts
-import { spawnSync as spawnSync10 } from "node:child_process";
-import { existsSync as existsSync6, realpathSync as realpathSync5 } from "node:fs";
-import path16 from "node:path";
+import { spawnSync as spawnSync11 } from "node:child_process";
+import { existsSync as existsSync7, realpathSync as realpathSync5 } from "node:fs";
+import path19 from "node:path";
 
 // packages/workit-core/src/core/task-contract.ts
 import { createHash, randomUUID } from "node:crypto";
@@ -7430,6 +7430,14 @@ function object(shape, params) {
   };
   return new ZodObject(def);
 }
+function looseObject(shape, params) {
+  return new ZodObject({
+    type: "object",
+    shape,
+    catchall: unknown(),
+    ...normalizeParams(params)
+  });
+}
 var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
   $ZodUnion.init(inst, def);
   ZodType.init(inst, def);
@@ -7930,76 +7938,16 @@ var provenanceSchema = object({
   workerId: nullableId
 }).strict();
 var entrySchema = (data) => object({ id, recordedAt: utc, provenance: provenanceSchema, data }).strict();
-var factSchema = object({
-  statement: text,
-  basis: _enum(["observed", "inferred", "unknown"]),
-  refs: array(refSchema)
-}).strict().check((ctx) => {
-  if (ctx.value.basis === "observed" && ctx.value.refs.length === 0)
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "observed facts require supporting references",
-      path: ["refs"]
-    });
-});
-var signalSchema = object({
-  value: union([boolean2(), literal("unknown")]),
-  basis: _enum(["observed", "inferred", "unknown"]),
-  reason: text,
+var RISK_TIERS = ["trivial", "normal", "high"];
+var judgmentSchema = object({
+  riskTier: _enum(RISK_TIERS),
+  behaviorChange: boolean2(),
+  productChoiceOpen: boolean2(),
+  needsPlan: boolean2(),
+  note: text.nullable(),
   refs: array(refSchema)
-}).strict().check((ctx) => {
-  const signal = ctx.value;
-  const valid = signal.value === "unknown" ? signal.basis === "unknown" : signal.basis === "observed" || signal.basis === "inferred";
-  if (!valid)
-    ctx.issues.push({
-      code: "custom",
-      input: signal,
-      message: "signal value and basis disagree",
-      path: []
-    });
-  if (signal.basis === "observed" && signal.refs.length === 0)
-    ctx.issues.push({
-      code: "custom",
-      input: signal,
-      message: "observed signals require supporting references",
-      path: ["refs"]
-    });
-});
-var signalSet = object({
-  approachUnknown: signalSchema,
-  productChoiceOpen: signalSchema,
-  behaviorChange: signalSchema,
-  mechanicalLowRisk: signalSchema,
-  durableAgreementNeeded: signalSchema,
-  coordinationPlanNeeded: signalSchema,
-  helperUseful: signalSchema,
-  testFirstPractical: signalSchema
-}).strict();
-var consequenceSchema = object({
-  area: _enum([
-    "behavior",
-    "public_contract",
-    "data",
-    "security",
-    "operations",
-    "reversibility",
-    "consumers"
-  ]),
-  fact: factSchema
-}).strict();
-var verificationSchema = object({
-  claim: text,
-  scope: scopeSchema,
-  availableChecks: array(refSchema),
-  gaps: array(text)
-}).strict();
-var assessmentSchema = object({
-  facts: array(factSchema),
-  signals: signalSet,
-  consequences: array(consequenceSchema),
-  verification: array(verificationSchema)
 }).strict();
+var legacyAssessmentSchema = looseObject({});
 var constraintSchema = object({
   id: nonEmpty,
   kind: _enum(["host", "project", "user"]),
@@ -8236,7 +8184,8 @@ var taskRecordSchema = object({
   progress: progressSchema,
   pauseReason: text.nullable().optional(),
   runtime: runtimeSchema.optional(),
-  assessments: array(entrySchema(assessmentSchema)),
+  assessments: array(entrySchema(legacyAssessmentSchema)),
+  judgments: array(entrySchema(judgmentSchema)).optional(),
   policy: policySchema.nullable(),
   policyChanges: array(policyChangeSchema),
   candidates: array(candidateSchema),
@@ -8412,14 +8361,15 @@ var taskOperations = {
     decisionIds: array(id).optional()
   })
 };
+var rawJudgment = record(string2(), unknown());
 var policyOperations = {
   assess: operation({
     action: literal("assess"),
     ...taskId,
     expectedRevision: revision.optional(),
-    assessment: assessmentSchema
+    judgment: rawJudgment
   }),
-  preview: operation({ action: literal("preview"), ...taskId, assessment: assessmentSchema }),
+  preview: operation({ action: literal("preview"), ...taskId, judgment: rawJudgment }),
   explain: operation({ action: literal("explain"), ...taskId })
 };
 var evidenceOperations = {
@@ -8458,7 +8408,10 @@ var decisionOperations = {
     ...taskId,
     expectedRevision: revision.optional(),
     purpose: decisionSchema.shape.purpose,
-    binding: decisionSchema.shape.binding,
+    binding: decisionSchema.shape.binding.extend({
+      taskId: id.optional(),
+      workspaceId: id.optional()
+    }),
     response: decisionSchema.shape.response,
     requirementIds: array(digest)
   }),
@@ -8512,6 +8465,15 @@ var operationSchemas = {
   worker: discriminatedUnion("action", Object.values(workerOperations)),
   state: discriminatedUnion("action", Object.values(stateOperations))
 };
+var OPERATION_ACTIONS = {
+  task: Object.keys(taskOperations),
+  policy: Object.keys(policyOperations),
+  evidence: Object.keys(evidenceOperations),
+  finding: Object.keys(findingOperations),
+  decision: Object.keys(decisionOperations),
+  worker: Object.keys(workerOperations),
+  state: Object.keys(stateOperations)
+};
 var withImplicitTask = (options) => Object.values(options).map((option) => ("taskId" in option.shape) ? option.extend({ taskId: id.optional() }) : option);
 var advertised = (options) => discriminatedUnion("action", withImplicitTask(options));
 var advertisedOperationSchemas = {
@@ -8545,103 +8507,6 @@ function parseOperation(family, input) {
   }));
   return failure2("invalid_input", "operation input is invalid", { fields });
 }
-function operationJsonSchema(family) {
-  return toJSONSchema(advertisedOperationSchemas[family], { target: "draft-2020-12" });
-}
-var OPERATION_SCHEMA_DEPTH = 1;
-var schemaShapeDescription = (value, depth = 0) => {
-  if (!value || typeof value !== "object")
-    return "value";
-  const schema = value;
-  if (Array.isArray(schema.oneOf) || Array.isArray(schema.anyOf)) {
-    const options = Array.isArray(schema.oneOf) ? schema.oneOf : schema.anyOf;
-    return `(${options.map((option) => schemaShapeDescription(option, depth)).join("|")})`;
-  }
-  if (schema.const !== undefined)
-    return `=${JSON.stringify(schema.const)}`;
-  if (Array.isArray(schema.enum))
-    return `[${schema.enum.map(String).join("|")}]`;
-  const type = Array.isArray(schema.type) ? schema.type.join("/") : schema.type;
-  if (type === "array")
-    return `arr<${schemaShapeDescription(schema.items, depth)}>`;
-  if (type === "object" && schema.properties && typeof schema.properties === "object") {
-    if (depth >= 2)
-      return "obj";
-    const required = new Set(Array.isArray(schema.required) ? schema.required : []);
-    const properties = schema.properties;
-    const fields = Object.entries(properties).map(([name, child]) => `${name}${required.has(name) ? "!" : ""}:${schemaShapeDescription(child, depth + 1)}`);
-    return `obj{${fields.join(",")}}`;
-  }
-  if (typeof type !== "string")
-    return "?";
-  return type.split("/").map((part) => ({ string: "str", boolean: "bool", number: "num", null: "null" })[part] ?? part).join("|");
-};
-var canonicalFieldsDescription = (value) => {
-  if (Array.isArray(value))
-    return `Canonical object fields: ${value.join(", ")}. Workit validates the complete nested value.`;
-  const isZodType = (schema) => ("_zod" in schema) && typeof schema._zod === "object";
-  const schema = isZodType(value) ? toJSONSchema(value, { target: "draft-2020-12" }) : value;
-  if (!schema.properties || typeof schema.properties !== "object") {
-    const variants = Array.isArray(schema.oneOf) ? schema.oneOf : Array.isArray(schema.anyOf) ? schema.anyOf : null;
-    return variants ? `Canonical shapes: ${variants.map((variant) => schemaShapeDescription(variant)).join(" | ")}. Full nested value is validated.` : "Canonical nested value; Workit validates the complete value.";
-  }
-  const properties = schema.properties;
-  const required = new Set(Array.isArray(schema.required) ? schema.required : []);
-  const fields = Object.entries(properties).map(([name, child]) => `${name}${required.has(name) ? "!" : ""}:${schemaShapeDescription(child)}`);
-  return `Fields (! required): ${fields.join(", ")}. Full nested value is validated.`;
-};
-function boundedOperationJsonSchema(family, maxDepth = OPERATION_SCHEMA_DEPTH, stringifiedObjects = false) {
-  const tolerate = (projected) => {
-    if (!stringifiedObjects)
-      return projected;
-    if (projected.properties && typeof projected.properties === "object")
-      return { ...projected, type: ["object", "string"] };
-    if (projected.items)
-      return { ...projected, type: ["array", "string"] };
-    if ("const" in projected && (typeof projected.const === "number" || typeof projected.const === "boolean"))
-      return { anyOf: [projected, { const: String(projected.const) }] };
-    if (projected.type === "object")
-      return { ...projected, type: ["object", "string"] };
-    if (projected.type === "array")
-      return { ...projected, type: ["array", "string"] };
-    return projected;
-  };
-  const collapse = (node, currentDepth) => {
-    if (Array.isArray(node))
-      return node.map((item) => collapse(item, currentDepth));
-    if (typeof node !== "object" || node === null)
-      return node;
-    const record = node;
-    if (record.properties && typeof record.properties === "object") {
-      const properties = record.properties;
-      const fields = Object.keys(properties);
-      if (currentDepth >= maxDepth || fields.length === 0) {
-        const description = stringifiedObjects ? `${canonicalFieldsDescription(record)} A JSON-encoded string is also accepted.` : canonicalFieldsDescription(record);
-        return tolerate({ type: "object", description });
-      }
-      return tolerate({
-        ...record,
-        properties: Object.fromEntries(Object.entries(record.properties).map(([key, child]) => [
-          key,
-          collapse(child, currentDepth + 1)
-        ]))
-      });
-    }
-    if (record.items)
-      return tolerate({ ...record, items: collapse(record.items, currentDepth) });
-    const composed = ["anyOf", "oneOf", "allOf"].filter((key) => Array.isArray(record[key]));
-    if (composed.length > 0) {
-      const projected = { ...record };
-      for (const key of composed)
-        projected[key] = record[key].map((item) => collapse(item, currentDepth));
-      return projected;
-    }
-    if ("const" in record)
-      return tolerate({ ...record });
-    return node;
-  };
-  return collapse(operationJsonSchema(family), 0);
-}
 function canonical(value, seen) {
   if (value === null || typeof value === "boolean" || typeof value === "string") {
     if (typeof value === "string" && invalidUnicode(value))
@@ -8730,6 +8595,402 @@ function requirementId(input) {
     }
   });
 }
+// packages/workit-core/src/core/operation-input.ts
+var str = (d, values) => ({
+  type: "string",
+  ...values ? { enum: values } : {},
+  ...d ? { d } : {}
+});
+var list = (d) => ({ type: "array", ...d ? { d } : {} });
+var bool = (d) => ({ type: "boolean", ...d ? { d } : {} });
+var int2 = (d) => ({ type: "integer", ...d ? { d } : {} });
+var scopeFields = {
+  paths: list("Scope paths (default: whole checkout)."),
+  exclusions: list(),
+  scope: str("Scope description.")
+};
+var refs = list("Paths or URLs.");
+var FLAT = {
+  task: {
+    fields: {
+      objective: str(),
+      ...scopeFields,
+      refs,
+      reason: str(),
+      summary: str(),
+      nextAction: str(),
+      blockers: list(),
+      outcome: str(undefined, ["verified", "accepted_limitations", "stopped"]),
+      decisionIds: list(),
+      status: str(undefined, ["open", "closed", "all"]),
+      query: str(),
+      limit: int2(),
+      view: str(undefined, ["summary", "full"])
+    }
+  },
+  policy: {
+    fields: {
+      riskTier: str("low=trivial, medium=normal.", ["trivial", "normal", "high", "low", "medium"]),
+      behaviorChange: bool("Observable behavior changes."),
+      productChoiceOpen: bool("A product/preference choice is still open."),
+      needsPlan: bool("Needs a written plan or spec first."),
+      note: str(),
+      refs: list("Plan/spec paths or URLs.")
+    }
+  },
+  evidence: {
+    fields: {
+      kind: str(undefined, ["check", "review", "investigation", "artifact"]),
+      claim: str(),
+      result: str(undefined, ["passed", "failed", "missing", "skipped"]),
+      summary: str(),
+      exitCode: int2(),
+      refs,
+      requirementIds: list(),
+      candidateId: str(),
+      beforeCandidateId: str(),
+      reviewSession: str("Reviewer session handle (review evidence).")
+    }
+  },
+  finding: {
+    fields: {
+      claim: str(),
+      consequence: str(),
+      ...scopeFields,
+      candidateId: str(),
+      refs,
+      findingId: str(),
+      disposition: str(undefined, ["open", "fixed", "dismissed", "deferred"]),
+      reason: str(),
+      evidenceIds: list(),
+      decisionIds: list()
+    }
+  },
+  decision: {
+    fields: {
+      purpose: str(undefined, ["design", "action", "limitation", "preference"]),
+      response: str(undefined, ["approved", "rejected", "stated"]),
+      presented: str("What the user was asked."),
+      choice: str("The user's stated choice (response=stated)."),
+      ...scopeFields,
+      refs,
+      requirementIds: list(),
+      decisionId: str(),
+      reason: str()
+    }
+  },
+  worker: {
+    fields: {
+      role: str(undefined, ["investigator", "reviewer", "implementer"]),
+      objective: str(),
+      ...scopeFields,
+      decisionIds: list(),
+      requirementIds: list(),
+      candidateId: str(),
+      stoppingCondition: str(),
+      workerId: str(),
+      outcome: str(undefined, ["completed", "failed", "cancelled"]),
+      summary: str(),
+      evidenceIds: list(),
+      findingIds: list(),
+      reason: str()
+    }
+  },
+  state: {
+    fields: { bundle: { type: "object", d: "An export bundle (object or JSON string)." } }
+  }
+};
+var COMMON = {
+  taskId: str("Omit for this branch's task."),
+  expectedRevision: str(),
+  expectedWorkspaceRevision: str()
+};
+var DESCRIPTIONS = {
+  task: "Workit task lifecycle for this branch's task (optional continuity).",
+  policy: "Judge the work in four flat calls (riskTier, behaviorChange, productChoiceOpen, needsPlan); Workit derives the checks, verdicts, decisions and plan it needs.",
+  evidence: "Record a note-level evidence entry; only `workit check` runs satisfy check gates.",
+  finding: "Record or resolve a review finding.",
+  decision: "Record or revoke a user decision (never an authorization).",
+  worker: "Assign, report or cancel a bounded helper.",
+  state: "Export or import a task handoff bundle."
+};
+var operationDescription = (family) => `${DESCRIPTIONS[family]} Flat fields; omit taskId and revisions.`;
+var READ_TASK_FIELDS = new Set(["status", "query", "limit", "view"]);
+var READ_ONLY_ACTIONS = new Set(["list", "inspect", "preview", "explain", "export"]);
+function flatOperationJsonSchema(family, options = {}) {
+  const spec = FLAT[family];
+  const actions = options.readOnly ? OPERATION_ACTIONS[family].filter((action) => READ_ONLY_ACTIONS.has(action)) : [...OPERATION_ACTIONS[family]];
+  if (!actions.length)
+    return null;
+  const property = (field) => {
+    const base = field.type === "array" ? { type: "array", items: { type: "string" } } : field.type === "object" ? { type: "object" } : { type: field.type };
+    const tolerant = options.stringTolerant && field.type !== "string" ? { type: [field.type, "string"] } : {};
+    return {
+      ...base,
+      ...tolerant,
+      ...field.enum ? { enum: field.enum } : {},
+      ...field.d ? { description: field.d } : {}
+    };
+  };
+  const properties = { action: { type: "string", enum: actions } };
+  const readField = (name) => name === "taskId" || (family === "task" ? READ_TASK_FIELDS.has(name) : family === "policy");
+  for (const [name, field] of Object.entries({ ...COMMON, ...spec.fields }))
+    if (options.readOnly ? readField(name) : !(family === "state" && name === "expectedRevision"))
+      properties[name] = property(field);
+  return {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    type: "object",
+    properties,
+    required: ["action"]
+  };
+}
+var isObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var decoded = (value) => {
+  if (typeof value !== "string")
+    return value;
+  const trimmed = value.trim();
+  if (!/^[[{]/.test(trimmed) && !/^(true|false|null|-?\d+)$/.test(trimmed))
+    return value;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return value;
+  }
+};
+var strings = (value) => {
+  const plain = decoded(value);
+  if (typeof plain === "string")
+    return plain.trim() ? [plain] : [];
+  return plain;
+};
+var refOf = (value) => {
+  if (typeof value !== "string")
+    return value;
+  return /^https?:\/\//i.test(value) ? { kind: "external", url: value } : { kind: "file", path: value.replace(/^\.\//, ""), digest: null };
+};
+var refList = (value) => {
+  const items = strings(value);
+  return Array.isArray(items) ? items.map(refOf) : items;
+};
+var take = (flat, keys, map = decoded) => {
+  const out = {};
+  for (const key of keys)
+    if (key in flat) {
+      out[key] = map(flat[key]);
+      delete flat[key];
+    }
+  return out;
+};
+var nest = (request, key, flat, defaults = {}) => {
+  const nested = isObject2(decoded(request[key])) ? decoded(request[key]) : null;
+  if (!nested && !Object.keys(flat).length)
+    return;
+  request[key] = { ...defaults, ...flat, ...nested };
+};
+var scopeOf = (flat, description) => {
+  const scope = decoded(flat.scope);
+  const has = "paths" in flat || "exclusions" in flat || typeof scope === "string";
+  const out = isObject2(scope) ? scope : has ? {
+    description: typeof scope === "string" ? scope : String(description ?? ""),
+    paths: strings(flat.paths ?? ["."]),
+    exclusions: strings(flat.exclusions ?? [])
+  } : null;
+  delete flat.scope;
+  delete flat.paths;
+  delete flat.exclusions;
+  return out;
+};
+var defaultScope = (description) => ({
+  description: typeof description === "string" ? description : "",
+  paths: ["."],
+  exclusions: []
+});
+var LISTS = [
+  "decisionIds",
+  "evidenceIds",
+  "findingIds",
+  "requirementIds",
+  "refs",
+  "blockers"
+];
+var ENVELOPE = new Set([
+  "schemaVersion",
+  "action",
+  "taskId",
+  "expectedRevision",
+  "expectedWorkspaceRevision",
+  "judgment"
+]);
+function normalizeOperationInput(family, input, host) {
+  if (!isObject2(input))
+    return input;
+  const request = { ...input };
+  if (!("schemaVersion" in request))
+    request.schemaVersion = 1;
+  else
+    request.schemaVersion = decoded(request.schemaVersion);
+  for (const key of ["limit", "exitCode"])
+    if (key in request)
+      request[key] = decoded(request[key]);
+  const action = request.action;
+  const flat = request;
+  switch (family) {
+    case "task": {
+      if (action === "start" || action === "revise") {
+        const intent = isObject2(decoded(request.intent)) ? decoded(request.intent) : {};
+        const objective = flat.objective ?? intent.objective;
+        const scope = scopeOf(flat, objective);
+        const fields = take(flat, ["objective"]);
+        const authorityRefs = "refs" in flat ? refList(flat.refs) : undefined;
+        delete flat.refs;
+        nest(request, "intent", {
+          ...fields,
+          ...scope ? { scope } : {},
+          ...authorityRefs ? { authorityRefs } : {}
+        }, { scope: defaultScope(objective), authorityRefs: [] });
+      } else if (action === "progress") {
+        const fields = take(flat, ["summary", "nextAction"]);
+        const blockers = "blockers" in flat ? strings(flat.blockers) : undefined;
+        delete flat.blockers;
+        nest(request, "progress", {
+          ...fields,
+          ...Array.isArray(blockers) ? {
+            blockers: blockers.map((item) => typeof item === "string" ? { reason: item, dependentAction: "", refs: [] } : item)
+          } : {}
+        }, { nextAction: null, blockers: [] });
+      } else if (action === "close" && "decisionIds" in flat)
+        flat.decisionIds = strings(flat.decisionIds);
+      break;
+    }
+    case "policy": {
+      if (action === "assess" || action === "preview") {
+        const judgment = isObject2(decoded(request.judgment)) ? { ...decoded(request.judgment) } : {};
+        for (const key of Object.keys(flat))
+          if (!ENVELOPE.has(key)) {
+            if (!(key in judgment))
+              judgment[key] = decoded(flat[key]);
+            delete flat[key];
+          }
+        request.judgment = judgment;
+      }
+      break;
+    }
+    case "evidence": {
+      if (action === "record") {
+        const review = "reviewSession" in flat ? decoded(flat.reviewSession) : undefined;
+        delete flat.reviewSession;
+        const fields = take(flat, [
+          "kind",
+          "claim",
+          "result",
+          "summary",
+          "exitCode",
+          "candidateId",
+          "beforeCandidateId",
+          "reviewContext"
+        ]);
+        if ("refs" in flat)
+          fields.refs = refList(flat.refs);
+        if ("requirementIds" in flat)
+          fields.requirementIds = strings(flat.requirementIds);
+        delete flat.refs;
+        delete flat.requirementIds;
+        if (typeof review === "string" && review)
+          fields.reviewContext = { kind: "host", host, handle: review };
+        nest(request, "evidence", fields, {
+          summary: "",
+          refs: [],
+          requirementIds: [],
+          exitCode: null,
+          reviewContext: null
+        });
+      }
+      break;
+    }
+    case "finding": {
+      if (action === "record") {
+        const scope = scopeOf(flat, flat.claim);
+        if (scope)
+          request.scope = scope;
+        else if (!("scope" in request))
+          request.scope = defaultScope(request.claim);
+        request.refs = "refs" in flat ? refList(flat.refs) : [];
+      }
+      break;
+    }
+    case "decision": {
+      if (action === "record") {
+        const binding = isObject2(decoded(request.binding)) ? decoded(request.binding) : {};
+        const presented = flat.presented ?? binding.presented;
+        const scope = scopeOf(flat, presented);
+        const fields = take(flat, ["presented"]);
+        const choice = flat.choice;
+        delete flat.choice;
+        const contentRefs = "refs" in flat ? refList(flat.refs) : undefined;
+        delete flat.refs;
+        nest(request, "binding", {
+          ...fields,
+          ...scope ? { scope } : {},
+          ...contentRefs ? { contentRefs } : {},
+          ...typeof choice === "string" ? { statedChoice: { ref: "choice", text: choice } } : {}
+        }, { scope: defaultScope(presented), contentRefs: [] });
+      }
+      break;
+    }
+    case "worker": {
+      if (action === "assign") {
+        const objective = flat.objective;
+        const scope = scopeOf(flat, objective);
+        const fields = take(flat, ["role", "objective", "candidateId", "stoppingCondition"]);
+        for (const key of ["decisionIds", "requirementIds"])
+          if (key in flat) {
+            fields[key] = strings(flat[key]);
+            delete flat[key];
+          }
+        nest(request, "assignment", { ...fields, ...scope ? { scope } : {} }, { scope: defaultScope(objective), decisionIds: [], requirementIds: [] });
+      } else if (action === "report") {
+        const fields = take(flat, ["outcome", "summary"]);
+        for (const key of ["evidenceIds", "findingIds"])
+          if (key in flat) {
+            fields[key] = strings(flat[key]);
+            delete flat[key];
+          }
+        nest(request, "report", fields, { evidenceIds: [], findingIds: [] });
+      }
+      break;
+    }
+    case "state": {
+      if ("bundle" in request)
+        request.bundle = decoded(request.bundle);
+      break;
+    }
+  }
+  const defaults = {
+    finding: { resolve: ["evidenceIds", "decisionIds"] },
+    decision: { record: ["requirementIds"] }
+  };
+  for (const key of defaults[family]?.[String(action)] ?? [])
+    if (!(key in request))
+      request[key] = [];
+  for (const key of LISTS)
+    if (key in request && typeof request[key] === "string")
+      request[key] = strings(request[key]);
+  return request;
+}
+function parseAdvertisedOperation(family, input, host) {
+  const request = normalizeOperationInput(family, input, host);
+  if (isObject2(request) && request.schemaVersion !== SCHEMA_VERSION)
+    return failure2("unsupported_version", "unsupported schema version", { operation: family });
+  const parsed = advertisedOperationSchemas[family].safeParse(request);
+  if (parsed.success)
+    return success(null, null, request);
+  return failure2("invalid_input", "operation input is invalid", {
+    fields: parsed.error.issues.map((issue) => ({
+      path: issue.code === "unrecognized_keys" ? issue.keys.join(".") : issue.path.join("."),
+      reason: issue.message
+    }))
+  });
+}
 // packages/workit-core/src/core/task-store.ts
 import { createHash as createHash4, randomUUID as randomUUID3 } from "node:crypto";
 import * as fs7 from "node:fs";
@@ -9784,7 +10045,7 @@ class LogDamage extends Error {
     this.upgrade = upgrade;
   }
 }
-var isObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isObject3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var parseEvent = (line, file, offset) => {
   let value;
   try {
@@ -9792,11 +10053,11 @@ var parseEvent = (line, file, offset) => {
   } catch {
     throw new LogDamage(`${file}: unreadable event at byte ${offset}`);
   }
-  if (!isObject2(value) || typeof value.v !== "number")
+  if (!isObject3(value) || typeof value.v !== "number")
     throw new LogDamage(`${file}: malformed event at byte ${offset}`);
   if (value.v > EVENT_VERSION)
     throw new LogDamage(`${file}: event format v${value.v} was written by a newer Workit; upgrade Workit to read this task`, true);
-  if (typeof value.seq !== "number" || !Number.isInteger(value.seq) || typeof value.type !== "string" || typeof value.id !== "string" || typeof value.task !== "string" || !isObject2(value.data))
+  if (typeof value.seq !== "number" || !Number.isInteger(value.seq) || typeof value.type !== "string" || typeof value.id !== "string" || typeof value.task !== "string" || !isObject3(value.data))
     throw new LogDamage(`${file}: malformed event at byte ${offset}`);
   return value;
 };
@@ -10067,13 +10328,13 @@ var KNOWN_TYPES = new Set([
   "decision.updated",
   "worker.updated"
 ]);
-var isObject3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var isKey = (value) => isObject3(value) && typeof value.key === "string" && (value.kind === "branch" || value.kind === "detached" || value.kind === "dir") && (value.branch === null || typeof value.branch === "string");
+var isObject4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isKey = (value) => isObject4(value) && typeof value.key === "string" && (value.kind === "branch" || value.kind === "detached" || value.kind === "dir") && (value.branch === null || typeof value.branch === "string");
 var BLOB_REF = "$blob";
-var blobRef = (value) => isObject3(value) && Object.keys(value).length === 1 && typeof value[BLOB_REF] === "string" && /^[0-9a-f]{64}$/.test(value[BLOB_REF]) ? value[BLOB_REF] : null;
+var blobRef = (value) => isObject4(value) && Object.keys(value).length === 1 && typeof value[BLOB_REF] === "string" && /^[0-9a-f]{64}$/.test(value[BLOB_REF]) ? value[BLOB_REF] : null;
 var blobDigest = (value) => createHash3("sha256").update(JSON.stringify(value)).digest("hex");
 var toBlob = (value, blobs) => {
-  if (!isObject3(value))
+  if (!isObject4(value))
     return value;
   const digest = blobDigest(value);
   blobs.write(digest, value);
@@ -10097,7 +10358,7 @@ var decode2 = (value, blobs) => {
     return blobs.read(digest);
   if (Array.isArray(value))
     return value.map((item) => decode2(item, blobs));
-  if (isObject3(value)) {
+  if (isObject4(value)) {
     const out = {};
     for (const [key, item] of Object.entries(value))
       out[key] = decode2(item, blobs);
@@ -10116,7 +10377,7 @@ function reduce(state, event, blobs) {
   }
   let next = state;
   if ("record" in data) {
-    if (!isObject3(data.record))
+    if (!isObject4(data.record))
       throw new LogDamage(`event ${event.seq} carries a malformed record`);
     next = {
       record: decode2(data.record, blobs),
@@ -10138,7 +10399,7 @@ function reduce(state, event, blobs) {
   }
   if ("key" in data)
     next.key = isKey(data.key) ? data.key : null;
-  if ("legacy" in data && isObject3(data.legacy))
+  if ("legacy" in data && isObject4(data.legacy))
     next.legacy = {
       path: String(data.legacy.path ?? ""),
       digest: String(data.legacy.digest ?? "")
@@ -10194,8 +10455,8 @@ var AUTO_COMPACT_BYTES = 2 * 1024 * 1024;
 var TOMBSTONE = Symbol("tombstone");
 var STALE_TEMPORARY_MS = 60 * 60000;
 var INDEX_VERSION = 3;
-var isObject4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var hostSession = (value) => isObject4(value) && value.kind === "host" && typeof value.host === "string" && typeof value.handle === "string" ? { host: value.host, handle: value.handle } : null;
+var isObject5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var hostSession = (value) => isObject5(value) && value.kind === "host" && typeof value.host === "string" && typeof value.handle === "string" ? { host: value.host, handle: value.handle } : null;
 var indexEntry = (task, key, legacy, file) => {
   const sessions = [];
   const intent = hostSession(task.intent.provenance.session);
@@ -11008,7 +11269,7 @@ class TaskStore {
   readSnapshot(taskId) {
     try {
       const value = JSON.parse(fs7.readFileSync(this.snapshotPath(taskId), "utf8"));
-      if (!isObject4(value) || value.v !== 1 || value.task !== taskId || typeof value.seq !== "number" || typeof value.lastId !== "string" || typeof value.lastStart !== "number" || typeof value.end !== "number" || !isObject4(value.record))
+      if (!isObject5(value) || value.v !== 1 || value.task !== taskId || typeof value.seq !== "number" || typeof value.lastId !== "string" || typeof value.lastStart !== "number" || typeof value.end !== "number" || !isObject5(value.record))
         return null;
       return value;
     } catch {
@@ -11354,11 +11615,11 @@ class TaskStore {
   readIndex() {
     try {
       const value = JSON.parse(fs7.readFileSync(this.paths().index, "utf8"));
-      if (!isObject4(value) || value.version !== INDEX_VERSION || !isObject4(value.tasks))
+      if (!isObject5(value) || value.version !== INDEX_VERSION || !isObject5(value.tasks))
         return {};
       const tasks = {};
       for (const [id, entry] of Object.entries(value.tasks))
-        if (isObject4(entry) && entry.id === id && typeof entry.file === "string" && typeof entry.status === "string" && typeof entry.updatedAt === "string" && typeof entry.workspaceId === "string" && Array.isArray(entry.sessions) && isObject4(entry.progress) && isObject4(entry.source))
+        if (isObject5(entry) && entry.id === id && typeof entry.file === "string" && typeof entry.status === "string" && typeof entry.updatedAt === "string" && typeof entry.workspaceId === "string" && Array.isArray(entry.sessions) && isObject5(entry.progress) && isObject5(entry.source))
           tasks[id] = entry;
       return tasks;
     } catch {
@@ -11402,12 +11663,12 @@ class TaskStore {
     return this.parseValue(value, schema, label);
   }
   parseValue(value, schema, label) {
-    if (isObject4(value) && "schemaVersion" in value && value.schemaVersion !== SCHEMA_VERSION)
+    if (isObject5(value) && "schemaVersion" in value && value.schemaVersion !== SCHEMA_VERSION)
       return failure2("unsupported_version", `unsupported ${label} schema version`);
     const parsed = parseStoredRecord(schema, value);
     if (parsed.success)
       return success(null, null, parsed.data);
-    const writerVersion = isObject4(value) && isObject4(value.runtime) ? value.runtime.updatedWith : null;
+    const writerVersion = isObject5(value) && isObject5(value.runtime) ? value.runtime.updatedWith : null;
     if (parsed.critical.length > 0)
       return failure2("recovery_required", `${label} record requires fields this Workit cannot read (${parsed.critical.join(", ")}); upgrade Workit before mutating this checkout`);
     if (typeof writerVersion === "string" && isNewerVersion(writerVersion, runtimeVersion()))
@@ -11609,7 +11870,7 @@ class TaskStore {
     }
     try {
       const value = JSON.parse(bytes);
-      if (isObject4(value) && isObject4(value.store) && value.store.format === "workit-store")
+      if (isObject5(value) && isObject5(value.store) && value.store.format === "workit-store")
         return TOMBSTONE;
     } catch {}
     return { bytes };
@@ -11654,7 +11915,7 @@ class TaskStore {
   isStub(file) {
     try {
       const value = JSON.parse(fs7.readFileSync(file, "utf8"));
-      return isObject4(value) && isObject4(value.store) && value.store.format === "workit-store";
+      return isObject5(value) && isObject5(value.store) && value.store.format === "workit-store";
     } catch {
       return false;
     }
@@ -11825,10 +12086,10 @@ var isUncertainWorker = (state) => UNCERTAIN_WORKER_STATES.includes(state);
 var workerBlocksTransition = (transition, state) => transition === "pause" ? false : isUncertainWorker(state);
 
 // packages/workit-core/src/core/task-evaluation.ts
-import { createHash as createHash6 } from "node:crypto";
-import * as fs10 from "node:fs";
-import { spawnSync as spawnSync5 } from "node:child_process";
-import path9 from "node:path";
+import { createHash as createHash7 } from "node:crypto";
+import * as fs11 from "node:fs";
+import { spawnSync as spawnSync6 } from "node:child_process";
+import path11 from "node:path";
 
 // packages/workit-core/src/check-config.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
@@ -12068,6 +12329,7 @@ var line = (run) => {
   const value = run.stdout.trim();
   return value ? value : null;
 };
+var safeArg = (value) => value.length > 0 && !value.startsWith("-");
 function headSha(cwd) {
   return line(git2(cwd, ["rev-parse", "--verify", "-q", "HEAD^{commit}"]));
 }
@@ -12159,124 +12421,704 @@ function worktreeSignal(cwd, options = {}) {
   }
   return `sig:${hash.digest("hex")}`;
 }
-
-// packages/workit-core/src/core/task-evaluation.ts
-var digestBytes = (value) => createHash6("sha256").update(value).digest("hex");
-var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path9.sep}`);
-var relative = (root, candidate) => path9.relative(root, candidate).split(path9.sep).join("/") || ".";
-var canonicalPath = (value) => {
-  if (typeof value !== "string" || !value)
-    return null;
-  if (value.includes("\\") || value.split("/").includes(".."))
+function patchId(cwd, base, head) {
+  if (!safeArg(base) || !safeArg(head))
     return null;
-  const normalized = path9.posix.normalize(value);
-  if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
-    return null;
-  return normalized === "." ? "." : normalized.replace(/\/$/, "");
-};
-var canonicalScope = (scope) => {
-  const paths = scope.paths.length ? scope.paths : ["."];
-  const normalizedPaths = paths.map(canonicalPath);
-  const normalizedExclusions = scope.exclusions.map(canonicalPath);
-  if (normalizedPaths.some((value) => value === null) || normalizedExclusions.some((value) => value === null))
+  const diff = git2(cwd, [
+    "diff",
+    "-U3",
+    "--diff-algorithm=myers",
+    "--indent-heuristic",
+    "--no-color",
+    "--no-ext-diff",
+    "--no-textconv",
+    "--no-renames",
+    "--full-index",
+    "--src-prefix=a/",
+    "--dst-prefix=b/",
+    `${base}...${head}`,
+    "--"
+  ]);
+  if (!diff.ok || !diff.stdout.trim())
     return null;
+  const id = git2(cwd, ["patch-id", "--stable"], { input: diff.stdout });
+  return line(id)?.split(/\s+/u)[0] ?? null;
+}
+function currentBranch(cwd) {
+  return line(git2(cwd, ["symbolic-ref", "--short", "-q", "HEAD"]));
+}
+
+// packages/workit-core/src/core/policy/derive.ts
+import { existsSync as existsSync3 } from "node:fs";
+import path10 from "node:path";
+
+// packages/workit-core/src/ledger.ts
+import { spawnSync as spawnSync5 } from "node:child_process";
+import { createHash as createHash6, randomBytes as randomBytes2 } from "node:crypto";
+import fs10 from "node:fs";
+import path9 from "node:path";
+var LEDGER_VERSION = 1;
+var PASSING = new Set(["verified", "tests-verified", "type-check-only"]);
+var FAILING = new Set(["failed", "blocked"]);
+var STRONG_RESULTS = new Set(["verified", "tests-verified"]);
+var PR_ROW_TYPES = new Set(["pr.created", "pr.status", "pr.merged"]);
+var err = (code, error, unblock) => ({
+  ok: false,
+  code,
+  error,
+  ...unblock ? { unblock } : {}
+});
+var gitRun2 = (cwd, args, timeoutMs = GIT_TIMEOUTS.local) => {
+  const run = spawnSync5("git", args, {
+    cwd,
+    encoding: "utf8",
+    timeout: timeoutMs,
+    killSignal: "SIGKILL",
+    windowsHide: true,
+    maxBuffer: 256 * 1024 * 1024,
+    env: {
+      ...process.env,
+      GIT_TERMINAL_PROMPT: "0",
+      GIT_OPTIONAL_LOCKS: "0",
+      LC_ALL: "C",
+      LANGUAGE: "C"
+    }
+  });
   return {
-    description: scope.description,
-    paths: [...new Set(normalizedPaths)],
-    exclusions: [...new Set(normalizedExclusions)]
+    ok: run.status === 0,
+    stdout: run.stdout ?? "",
+    stderr: run.error ? String(run.error.message) : run.stderr ?? ""
   };
 };
-var excluded = (value, exclusions) => exclusions.some((item) => item === value || item !== "." && value.startsWith(`${item}/`));
-var scopeMatches = (value, scope) => {
-  const normalized = canonicalScope(scope);
-  if (!normalized)
-    return false;
-  const paths = normalized.paths;
-  return paths.some((item) => item === "." || value === item || value.startsWith(`${item}/`)) && !excluded(value, normalized.exclusions);
-};
-var pathRelevant = (value, scope) => scopeMatches(value, scope);
-var compareCodeUnits2 = (left, right) => {
-  const length = Math.min(left.length, right.length);
-  for (let index = 0;index < length; index += 1) {
-    const difference = left.charCodeAt(index) - right.charCodeAt(index);
-    if (difference !== 0)
-      return difference;
-  }
-  return left.length - right.length;
+var git3 = (cwd, args) => {
+  const run = gitRun2(cwd, args);
+  const value = run.ok ? run.stdout.trim() : "";
+  return value ? value : null;
 };
-var gitPaths = (root) => {
-  const result = spawnSync5("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
-    cwd: root,
-    encoding: "buffer"
-  });
-  if (result.status !== 0) {
-    const stderr = result.stderr?.toString("utf8") ?? "";
-    return {
-      paths: [],
-      uncertain: !/not a git repository/i.test(stderr),
-      git: !/not a git repository/i.test(stderr)
-    };
-  }
-  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path9.sep).join("/")) : [];
-  const stagedDeleted = spawnSync5("git", ["diff", "--cached", "--name-only", "--diff-filter=D", "-z"], { cwd: root, encoding: "buffer" });
-  if (stagedDeleted.status !== 0) {
-    const stderr = stagedDeleted.stderr?.toString("utf8") ?? "";
-    if (!/not a git repository/i.test(stderr))
-      return { paths, uncertain: true, git: true };
-  } else if (stagedDeleted.stdout) {
-    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path9.sep).join("/")));
+var safeRef = (value) => value.length > 0 && !value.startsWith("-");
+function resolveCommit(cwd, ref) {
+  if (!safeRef(ref))
+    return null;
+  return git3(cwd, ["rev-parse", "--verify", "-q", `${ref}^{commit}`]);
+}
+function branchHead(cwd, branch) {
+  if (!safeRef(branch))
+    return null;
+  return resolveCommit(cwd, `refs/heads/${branch}`) ?? resolveCommit(cwd, `refs/remotes/origin/${branch}`);
+}
+function defaultBase(cwd) {
+  const originHead = git3(cwd, ["symbolic-ref", "-q", "--short", "refs/remotes/origin/HEAD"]);
+  if (originHead && resolveCommit(cwd, originHead))
+    return originHead;
+  for (const candidate of ["origin/main", "origin/master", "main", "master"])
+    if (resolveCommit(cwd, candidate))
+      return candidate;
+  return null;
+}
+function diffHash(cwd, base, head) {
+  if (!safeRef(base) || !safeRef(head))
+    return null;
+  const diff = gitRun2(cwd, [
+    "diff",
+    "-U3",
+    "--diff-algorithm=myers",
+    "--indent-heuristic",
+    "--no-color",
+    "--no-ext-diff",
+    "--no-textconv",
+    "--no-renames",
+    "--full-index",
+    "--binary",
+    "--src-prefix=a/",
+    "--dst-prefix=b/",
+    `${base}...${head}`,
+    "--"
+  ], GIT_TIMEOUTS.worktree);
+  if (!diff.ok || !diff.stdout)
+    return null;
+  const hash = createHash6("sha256");
+  for (const line of diff.stdout.split(`
+`)) {
+    if (line.startsWith("index "))
+      continue;
+    hash.update(line.startsWith("@@ ") ? "@@" : line);
+    hash.update(`
+`);
   }
-  return { paths: [...new Set(paths)], uncertain: false, git: true };
+  return `sha256:${hash.digest("hex")}`;
+}
+function storeRoot(cwd) {
+  const location = resolveStore(path9.resolve(cwd));
+  if (location instanceof Error)
+    return err("unavailable", location.message.replace(/; fix the repository.*$/u, ""), "fix the repository (git status should work here) or run from a non-git directory");
+  return { ok: true, value: { root: location.dir, shared: location.shared } };
+}
+function ledgerPath(cwd) {
+  const root = storeRoot(cwd);
+  return root.ok ? { ok: true, value: path9.join(root.value.root, "ledger", "ledger.jsonl") } : root;
+}
+var NETWORK_FS_TYPES = new Set([
+  26985,
+  20859,
+  4266872130,
+  4283649346,
+  1702057286,
+  1397113167,
+  12805120,
+  16914839,
+  1196443219,
+  198183888
+]);
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var str2 = (value) => typeof value === "string" ? value : null;
+var normalizeActor = (value) => {
+  const actor = isRecord2(value) ? value : {};
+  return {
+    host: str2(actor.host) ?? "unknown",
+    session: str2(actor.session),
+    agentId: str2(actor.agentId)
+  };
 };
-var walk = (root, directory, output) => {
-  let names;
+function supersedeAllowed(by, target) {
+  if (by.type !== target.type)
+    return `a ${by.type} row cannot supersede a ${target.type} row`;
+  if (!by.actor.session || by.actor.session !== target.actor.session)
+    return "only the session that wrote a row can supersede it";
+  if (by.type === "verdict" && by.self === true && target.self !== true)
+    return "a self verdict cannot replace an independent verdict";
+  return null;
+}
+function readLedger(cwd) {
+  const file = ledgerPath(cwd);
+  if (!file.ok)
+    return file;
+  let text = "";
   try {
-    names = fs10.readdirSync(directory);
-  } catch {
-    return true;
+    text = fs10.readFileSync(file.value, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return { ok: true, value: { path: file.value, rows: [], skipped: 0 } };
+    return err("unavailable", `cannot read ${file.value}: ${error.message}`);
   }
-  let uncertain = false;
-  for (const name of names) {
-    if (name === ".git" || name === ".workit")
+  const rows = [];
+  let skipped = 0;
+  for (const raw of text.split(`
+`)) {
+    const trimmed = raw.trim();
+    if (!trimmed)
       continue;
-    const target = path9.join(directory, name);
-    let stat;
+    let parsed;
     try {
-      stat = fs10.lstatSync(target);
+      parsed = JSON.parse(trimmed);
     } catch {
-      uncertain = true;
+      skipped += 1;
       continue;
     }
-    const item = relative(root, target);
-    output.add(item);
-    if (stat.isDirectory() && !stat.isSymbolicLink())
-      uncertain = walk(root, target, output) || uncertain;
-  }
-  return uncertain;
-};
-var scopeRoots = (root, scope) => {
-  const roots = [];
-  for (const item of scope.paths.length ? scope.paths : ["."]) {
-    const target = path9.resolve(root, item);
-    if (!inside(root, target))
-      return failure2("invalid_input", `candidate scope escapes checkout: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} is outside the checkout` }] });
-    let ancestor = target;
-    while (!fs10.existsSync(ancestor) && ancestor !== root)
-      ancestor = path9.dirname(ancestor);
-    try {
-      if (!inside(root, fs10.realpathSync(ancestor)))
-        return failure2("invalid_input", `candidate scope escapes checkout through a symlink: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} resolves outside the checkout` }] });
-    } catch {
-      return failure2("invalid_input", `candidate scope cannot be inspected: ${item}`);
+    if (!isRecord2(parsed) || !str2(parsed.id) || !str2(parsed.type) || !str2(parsed.at)) {
+      skipped += 1;
+      continue;
     }
-    roots.push(target);
+    const pr = typeof parsed.pr === "number" && Number.isInteger(parsed.pr) ? parsed.pr : undefined;
+    rows.push({
+      ...parsed,
+      v: typeof parsed.v === "number" ? parsed.v : LEDGER_VERSION,
+      id: parsed.id,
+      at: parsed.at,
+      type: parsed.type,
+      actor: normalizeActor(parsed.actor),
+      branch: str2(parsed.branch),
+      head: str2(parsed.head),
+      base: str2(parsed.base),
+      baseSha: str2(parsed.baseSha),
+      patchId: str2(parsed.patchId),
+      diffHash: str2(parsed.diffHash),
+      tree: str2(parsed.tree),
+      dirty: typeof parsed.dirty === "boolean" ? parsed.dirty : null,
+      ...pr === undefined ? {} : { pr },
+      ...str2(parsed.supersedes) ? { supersedes: parsed.supersedes } : {},
+      seq: rows.length + 1,
+      superseded: false,
+      supersedeIgnored: false
+    });
   }
-  return success(null, null, roots);
+  const byId = new Map;
+  for (const row of rows) {
+    const target = row.supersedes ? byId.get(row.supersedes) : undefined;
+    if (target && supersedeAllowed(row, target) === null)
+      target.superseded = true;
+    else if (row.supersedes)
+      row.supersedeIgnored = true;
+    if (!byId.has(row.id))
+      byId.set(row.id, row);
+  }
+  return { ok: true, value: { path: file.value, rows, skipped } };
+}
+function verdictBasis(verdict, current) {
+  if (verdict.head && verdict.head === current.head)
+    return "fresh";
+  if (verdict.patchId && verdict.patchId === current.patchId && verdict.diffHash && verdict.diffHash === current.diffHash)
+    return "carried";
+  return "stale";
+}
+var isLiveVerdict = (row) => row.type === "verdict" && typeof row.result === "string" && !row.superseded;
+function trailerSessions(cwd, base, head) {
+  if (!base || !head || !safeRef(base) || !safeRef(head))
+    return [];
+  const out = git3(cwd, [
+    "log",
+    "--format=%(trailers:key=Workit-Session,valueonly,separator=%x00)",
+    `${base}..${head}`
+  ]);
+  return (out ?? "").split(/[\0\n]/u).map((value) => value.trim()).filter(Boolean);
+}
+function authorSessions(cwd, rows, branch, range = { base: null, head: null }) {
+  const sessions = new Set;
+  for (const row of rows) {
+    if (row.branch !== branch || row.type !== "commit.recorded" && row.type !== "task.opened")
+      continue;
+    const session = str2(row.session) ?? row.actor.session;
+    if (session)
+      sessions.add(session);
+  }
+  for (const session of trailerSessions(cwd, range.base, range.head))
+    sessions.add(session);
+  return sessions;
+}
+var independenceReasons = (row, authors) => {
+  const reasons = [];
+  if (!row.actor.session)
+    reasons.push("no_session");
+  else if (authors.has(row.actor.session))
+    reasons.push("author_session");
+  if (row.self === true && !reasons.includes("no_session"))
+    reasons.push("self");
+  return reasons;
+};
+function effectiveOf(rows, authors) {
+  let effective = null;
+  for (const row of rows) {
+    if (!effective) {
+      effective = row;
+      continue;
+    }
+    const rowIndependent = independenceReasons(row, authors).length === 0;
+    const effIndependent = independenceReasons(effective, authors).length === 0;
+    if (effIndependent && !rowIndependent)
+      continue;
+    if (effIndependent && FAILING.has(String(effective.result)) && row.actor.session === effective.actor.session)
+      continue;
+    effective = row;
+  }
+  return effective;
+}
+function restackCarries(rows, branch, from, to) {
+  if (!from || !to)
+    return false;
+  const edges = new Map;
+  for (const row of rows)
+    if (row.type === "stack.restacked" && row.observer === "workit_cli" && row.branch === branch && row.patchEqual === true && typeof row.fromHead === "string" && row.head)
+      edges.set(row.fromHead, [...edges.get(row.fromHead) ?? [], row.head]);
+  const seen = new Set([from]);
+  const queue = [from];
+  while (queue.length) {
+    const next = queue.shift();
+    if (next === to)
+      return true;
+    for (const target of edges.get(next) ?? [])
+      if (!seen.has(target)) {
+        seen.add(target);
+        queue.push(target);
+      }
+  }
+  return false;
+}
+function checkVerdicts(cwd, branch, rows) {
+  const head = branchHead(cwd, branch);
+  const fallbackBase = defaultBase(cwd);
+  const keyCache = new Map;
+  const keyFor = (base) => {
+    if (!base || !head)
+      return { patchId: null, diffHash: null };
+    let key = keyCache.get(base);
+    if (!key) {
+      key = { patchId: patchId(cwd, base, head), diffHash: diffHash(cwd, base, head) };
+      keyCache.set(base, key);
+    }
+    return key;
+  };
+  const authors = authorSessions(cwd, rows, branch, { base: fallbackBase, head });
+  const byKind = new Map;
+  for (const row of rows)
+    if (row.branch === branch && isLiveVerdict(row)) {
+      const kind = typeof row.kind === "string" ? row.kind : "review";
+      byKind.set(kind, [...byKind.get(kind) ?? [], row]);
+    }
+  const verdicts = [];
+  for (const [kind, list] of byKind) {
+    const row = effectiveOf(list, authors);
+    if (!row)
+      continue;
+    let basis = verdictBasis(row, { head, ...keyFor(row.base ?? fallbackBase) });
+    if (basis === "stale" && restackCarries(rows, branch, row.head, head))
+      basis = "carried";
+    const current = basis !== "stale";
+    const independence = independenceReasons(row, authors);
+    const reasons = [
+      ...current ? [] : ["stale"],
+      ...PASSING.has(String(row.result)) ? [] : ["not_passing"],
+      ...independence
+    ];
+    verdicts.push({
+      kind,
+      basis,
+      current,
+      independent: independence.length === 0,
+      accepted: reasons.length === 0,
+      reasons,
+      verdict: row
+    });
+  }
+  verdicts.sort((a, b) => a.verdict.seq - b.verdict.seq);
+  const newestCurrent = verdicts.findLast((entry) => entry.current) ?? verdicts.at(-1) ?? null;
+  const failing = verdicts.find((entry) => entry.current && entry.independent && FAILING.has(String(entry.verdict.result)));
+  const newestAccepted = verdicts.findLast((entry) => entry.accepted) ?? null;
+  const accepted = newestAccepted && !failing ? { accepted: true, verdict: newestAccepted.verdict, reasons: [] } : {
+    accepted: false,
+    verdict: failing?.verdict ?? null,
+    reasons: failing ? ["failing_verdict"] : newestCurrent?.reasons ?? ["no_verdict"]
+  };
+  const selfEntry = failing ? undefined : verdicts.findLast((entry) => entry.current && !entry.independent && STRONG_RESULTS.has(String(entry.verdict.result)));
+  return {
+    branch,
+    head,
+    review: accepted.accepted ? "verified" : selfEntry ? "self-reviewed" : "unreviewed",
+    selfVerdict: accepted.accepted ? null : selfEntry?.verdict ?? null,
+    base: newestCurrent?.verdict.base ?? fallbackBase,
+    patchId: keyFor(newestCurrent?.verdict.base ?? fallbackBase).patchId,
+    current: { basis: newestCurrent?.basis ?? "none", verdict: newestCurrent?.verdict ?? null },
+    accepted,
+    verdicts,
+    authors: [...authors].toSorted()
+  };
+}
+var OBSERVED_ONLY = new Set(["check", ...PR_ROW_TYPES]);
+
+// packages/workit-core/src/core/policy/derive.ts
+var RULES = {
+  test: "check:test",
+  self: "verdict:self",
+  nonAuthor: "verdict:non-author",
+  verified: "verdict:verified",
+  product: "decision:product",
+  plan: "plan"
+};
+var derived2 = (spec) => ({
+  ...spec,
+  id: requirementId({
+    ruleId: spec.ruleId,
+    scope: spec.scope,
+    satisfaction: spec.satisfaction,
+    before: spec.before,
+    dependentAction: spec.dependentAction
+  })
+});
+var sorted = (values) => [...new Set(values)].toSorted();
+var normalizedScope = (scope) => ({
+  description: scope.description,
+  paths: sorted(scope.paths),
+  exclusions: sorted(scope.exclusions)
+});
+function deriveRequirements(judgment, scope, constraints, verification = "self") {
+  const out = [];
+  const base = { scope, dependentAction: null };
+  if (judgment.behaviorChange)
+    out.push(derived2({
+      ...base,
+      ruleId: RULES.test,
+      dimension: "testing",
+      reason: "Behavior changes: the configured test check must pass on the final tree.",
+      satisfaction: "Run `workit check test` on the final tree.",
+      before: "close",
+      acceptanceAllowed: false
+    }));
+  if (judgment.behaviorChange && judgment.riskTier === "normal")
+    out.push(verification === "independent" ? derived2({
+      ...base,
+      ruleId: RULES.nonAuthor,
+      dimension: "review",
+      reason: "This workspace requires independent verification: a session that did not author the change records the verdict.",
+      satisfaction: "An independent session records a passing verdict: `workit ledger verdict verified --how <what it exercised>`.",
+      before: "close",
+      acceptanceAllowed: false
+    }) : derived2({
+      ...base,
+      ruleId: RULES.self,
+      dimension: "review",
+      reason: "A behavior change needs a recorded verdict; the author's own is allowed and is shown as self-reviewed, never verified.",
+      satisfaction: "After an observed passing `workit check test`, record `workit ledger verdict tests-verified --self --how <what you ran>` (or have a verifier record one).",
+      before: "close",
+      acceptanceAllowed: false
+    }));
+  if (judgment.riskTier === "high")
+    out.push(derived2({
+      ...base,
+      ruleId: RULES.verified,
+      dimension: "review",
+      reason: "High risk: an independent verifier must exercise the live surface.",
+      satisfaction: "An independent verifier runs the real surface and records `workit ledger verdict verified --kind live --how <what it exercised>`.",
+      before: "close",
+      acceptanceAllowed: false
+    }));
+  if (judgment.productChoiceOpen)
+    out.push(derived2({
+      ...base,
+      ruleId: RULES.product,
+      dimension: "decisions",
+      reason: "A product or preference choice is open; the user decides it before code is written.",
+      satisfaction: 'Ask the user (with your recommendation), then record the answer: `workit ledger decision "<choice>" --why "<reason>"`.',
+      before: "write",
+      acceptanceAllowed: false
+    }));
+  if (judgment.needsPlan || judgment.riskTier === "high")
+    out.push(derived2({
+      ...base,
+      ruleId: RULES.plan,
+      dimension: "artifacts",
+      reason: judgment.needsPlan ? "The work needs a written plan or spec before implementation." : "High-risk work needs a written plan before implementation.",
+      satisfaction: "Write the plan or spec (e.g. docs/plans/<slug>.md; docs and Markdown writes stay allowed), then record it: `workit policy assess --ref <path>`.",
+      before: "write",
+      acceptanceAllowed: true
+    }));
+  for (const constraint of constraints)
+    for (const obligation of constraint.requires)
+      out.push(derived2({
+        ruleId: `project-constraint:${constraint.id}:${obligation.kind}:${sha256({
+          kind: obligation.kind,
+          scope: normalizedScope(obligation.scope),
+          refs: obligation.refs.map((ref) => JSON.stringify(ref)).toSorted(),
+          method: obligation.method,
+          before: obligation.before,
+          dependentAction: obligation.dependentAction
+        })}`,
+        dimension: obligation.method ?? (obligation.kind === "check" ? "verification" : obligation.kind === "decision" ? "decisions" : "challenge"),
+        scope: obligation.scope,
+        reason: `${constraint.kind} constraint requires ${obligation.kind}: ${constraint.statement}`,
+        satisfaction: `Satisfy the constraint obligation using its referenced ${obligation.kind}.`,
+        before: obligation.before,
+        dependentAction: obligation.dependentAction,
+        acceptanceAllowed: constraint.acceptanceAllowed && obligation.kind !== "decision"
+      }));
+  const seen = new Set;
+  return out.filter((item) => seen.has(item.id) ? false : (seen.add(item.id), true));
+}
+var latestJudgment = (task) => task.judgments?.at(-1)?.data ?? null;
+var ledgerView = (root) => {
+  let branch;
+  let rows;
+  return {
+    branch: () => branch === undefined ? branch = currentBranch(root) : branch,
+    rows: () => {
+      if (rows === undefined) {
+        const read = readLedger(root);
+        rows = read.ok ? read.value.rows : [];
+      }
+      return rows;
+    }
+  };
+};
+var productDecision = (task, ledger) => {
+  const decisions = task.decisions.filter((entry) => entry.data.revoked === null && (entry.data.response === "approved" || entry.data.response === "stated") && entry.data.purpose !== "limitation");
+  if (decisions.length)
+    return {
+      met: true,
+      reason: "the user's decision is recorded on the task",
+      decisionIds: decisions.map((entry) => entry.id)
+    };
+  const since = Date.parse(task.createdAt);
+  const branch = ledger.branch();
+  const row = ledger.rows().findLast((item) => item.type === "decision" && !item.superseded && (item.branch ?? null) === branch && Date.parse(item.at) >= since);
+  return row ? { met: true, reason: `ledger decision ${row.id} records the choice`, decisionIds: [] } : {
+    met: false,
+    reason: 'open product choice: ask the user, then `workit ledger decision "<choice>" --why "<reason>"` (or re-judge productChoiceOpen=false if it is not open)',
+    decisionIds: []
+  };
+};
+var planRecorded = (task, root) => {
+  const cited = (latestJudgment(task)?.refs ?? []).find((ref) => ref.kind === "external" || ref.kind === "file" && existsSync3(path10.resolve(root, ref.path)));
+  if (cited)
+    return {
+      met: true,
+      reason: `plan recorded: ${cited.kind === "file" ? cited.path : cited.kind === "external" ? cited.url : ""}`,
+      decisionIds: []
+    };
+  const artifact = task.evidence.some((entry) => entry.data.kind === "artifact" && entry.data.result === "passed");
+  return artifact ? { met: true, reason: "a passing artifact records the plan", decisionIds: [] } : {
+    met: false,
+    reason: "no plan recorded: write it (docs/ and Markdown writes stay allowed), then `workit policy assess --ref <path>`",
+    decisionIds: []
+  };
+};
+var verdict = (requirement, root, ledger) => {
+  const branch = ledger.branch();
+  if (!branch)
+    return { met: false, reason: "no branch is checked out to hold a verdict", decisionIds: [] };
+  const check = checkVerdicts(root, branch, ledger.rows());
+  const failing = check.accepted.reasons.includes("failing_verdict");
+  const strong = (entry) => STRONG_RESULTS.has(String(entry.verdict.result));
+  const met = !failing && (requirement.ruleId === RULES.verified ? check.verdicts.find((entry) => entry.accepted && entry.kind === "live" && String(entry.verdict.result) === "verified") : requirement.ruleId === RULES.nonAuthor ? check.verdicts.find((entry) => entry.accepted && strong(entry)) : check.verdicts.find((entry) => entry.current && strong(entry)));
+  if (met)
+    return {
+      met: true,
+      reason: `${met.accepted ? "accepted independent" : "self-reviewed (author's own)"} ${String(met.verdict.result)} verdict ${met.verdict.id}`,
+      decisionIds: []
+    };
+  const why = failing ? "a current independent verdict fails" : check.verdicts.some((entry) => entry.current && entry.verdict.result === "type-check-only") ? "type-check-only does not prove a behavior change" : (check.accepted.reasons.join(", ") || "no_verdict").replace(/_/g, " ");
+  const unblock = requirement.ruleId === RULES.self ? "record your own verdict after an observed `workit check test`: `workit ledger verdict tests-verified --self --how <what you ran>` (shown as self-reviewed), or have a verifier record one" : `an independent session records \`workit ledger verdict verified${requirement.ruleId === RULES.verified ? " --kind live" : ""} --how <what it exercised>\``;
+  return { met: false, reason: `${why}: ${unblock}`, decisionIds: [] };
+};
+function derivedRuleStatus(task, requirement, root, ledger) {
+  switch (requirement.ruleId) {
+    case RULES.product:
+      return productDecision(task, ledger);
+    case RULES.plan:
+      return planRecorded(task, root);
+    case RULES.self:
+    case RULES.nonAuthor:
+    case RULES.verified:
+      return verdict(requirement, root, ledger);
+    default:
+      return null;
+  }
+}
+function writeBlockers(task, root) {
+  if (task.status === "closed" || !task.policy)
+    return [];
+  const ledger = ledgerView(root);
+  return task.policy.requirements.flatMap((requirement) => {
+    if (requirement.before !== "write")
+      return [];
+    const status = derivedRuleStatus(task, requirement, root, ledger);
+    return status && !status.met ? [{ ruleId: requirement.ruleId, reason: status.reason }] : [];
+  });
+}
+
+// packages/workit-core/src/core/task-evaluation.ts
+var digestBytes = (value) => createHash7("sha256").update(value).digest("hex");
+var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path11.sep}`);
+var relative = (root, candidate) => path11.relative(root, candidate).split(path11.sep).join("/") || ".";
+var canonicalPath = (value) => {
+  if (typeof value !== "string" || !value)
+    return null;
+  if (value.includes("\\") || value.split("/").includes(".."))
+    return null;
+  const normalized = path11.posix.normalize(value);
+  if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
+    return null;
+  return normalized === "." ? "." : normalized.replace(/\/$/, "");
+};
+var canonicalScope = (scope) => {
+  const paths = scope.paths.length ? scope.paths : ["."];
+  const normalizedPaths = paths.map(canonicalPath);
+  const normalizedExclusions = scope.exclusions.map(canonicalPath);
+  if (normalizedPaths.some((value) => value === null) || normalizedExclusions.some((value) => value === null))
+    return null;
+  return {
+    description: scope.description,
+    paths: [...new Set(normalizedPaths)],
+    exclusions: [...new Set(normalizedExclusions)]
+  };
+};
+var excluded = (value, exclusions) => exclusions.some((item) => item === value || item !== "." && value.startsWith(`${item}/`));
+var scopeMatches = (value, scope) => {
+  const normalized = canonicalScope(scope);
+  if (!normalized)
+    return false;
+  const paths = normalized.paths;
+  return paths.some((item) => item === "." || value === item || value.startsWith(`${item}/`)) && !excluded(value, normalized.exclusions);
+};
+var pathRelevant = (value, scope) => scopeMatches(value, scope);
+var compareCodeUnits2 = (left, right) => {
+  const length = Math.min(left.length, right.length);
+  for (let index = 0;index < length; index += 1) {
+    const difference = left.charCodeAt(index) - right.charCodeAt(index);
+    if (difference !== 0)
+      return difference;
+  }
+  return left.length - right.length;
+};
+var gitPaths = (root) => {
+  const result = spawnSync6("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+    cwd: root,
+    encoding: "buffer"
+  });
+  if (result.status !== 0) {
+    const stderr = result.stderr?.toString("utf8") ?? "";
+    return {
+      paths: [],
+      uncertain: !/not a git repository/i.test(stderr),
+      git: !/not a git repository/i.test(stderr)
+    };
+  }
+  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path11.sep).join("/")) : [];
+  const stagedDeleted = spawnSync6("git", ["diff", "--cached", "--name-only", "--diff-filter=D", "-z"], { cwd: root, encoding: "buffer" });
+  if (stagedDeleted.status !== 0) {
+    const stderr = stagedDeleted.stderr?.toString("utf8") ?? "";
+    if (!/not a git repository/i.test(stderr))
+      return { paths, uncertain: true, git: true };
+  } else if (stagedDeleted.stdout) {
+    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path11.sep).join("/")));
+  }
+  return { paths: [...new Set(paths)], uncertain: false, git: true };
+};
+var walk = (root, directory, output) => {
+  let names;
+  try {
+    names = fs11.readdirSync(directory);
+  } catch {
+    return true;
+  }
+  let uncertain = false;
+  for (const name of names) {
+    if (name === ".git" || name === ".workit")
+      continue;
+    const target = path11.join(directory, name);
+    let stat;
+    try {
+      stat = fs11.lstatSync(target);
+    } catch {
+      uncertain = true;
+      continue;
+    }
+    const item = relative(root, target);
+    output.add(item);
+    if (stat.isDirectory() && !stat.isSymbolicLink())
+      uncertain = walk(root, target, output) || uncertain;
+  }
+  return uncertain;
+};
+var scopeRoots = (root, scope) => {
+  const roots = [];
+  for (const item of scope.paths.length ? scope.paths : ["."]) {
+    const target = path11.resolve(root, item);
+    if (!inside(root, target))
+      return failure2("invalid_input", `candidate scope escapes checkout: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} is outside the checkout` }] });
+    let ancestor = target;
+    while (!fs11.existsSync(ancestor) && ancestor !== root)
+      ancestor = path11.dirname(ancestor);
+    try {
+      if (!inside(root, fs11.realpathSync(ancestor)))
+        return failure2("invalid_input", `candidate scope escapes checkout through a symlink: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} resolves outside the checkout` }] });
+    } catch {
+      return failure2("invalid_input", `candidate scope cannot be inspected: ${item}`);
+    }
+    roots.push(target);
+  }
+  return success(null, null, roots);
 };
 function captureCandidate(root, scope, environment = []) {
   let checkout;
   try {
-    checkout = fs10.realpathSync(root);
+    checkout = fs11.realpathSync(root);
   } catch {
     return failure2("invalid_input", "candidate root does not exist");
   }
@@ -12294,11 +13136,11 @@ function captureCandidate(root, scope, environment = []) {
     if (item === ".git" || item === ".workit")
       continue;
     names.add(item);
-    if (!fs10.existsSync(target))
+    if (!fs11.existsSync(target))
       continue;
     let stat;
     try {
-      stat = fs10.lstatSync(target);
+      stat = fs11.lstatSync(target);
     } catch {
       uncertain = true;
       continue;
@@ -12314,17 +13156,17 @@ function captureCandidate(root, scope, environment = []) {
   for (const item of [...names].toSorted()) {
     if (!scopeMatches(item, normalizedScope))
       continue;
-    const target = path9.join(checkout, item);
+    const target = path11.join(checkout, item);
     try {
-      const stat = fs10.lstatSync(target);
+      const stat = fs11.lstatSync(target);
       if (stat.isSymbolicLink()) {
-        const link = fs10.readlinkSync(target);
+        const link = fs11.readlinkSync(target);
         files.push({ path: item, kind: "symlink", digest: digestBytes(link), executable: null });
       } else if (stat.isFile()) {
         files.push({
           path: item,
           kind: "file",
-          digest: digestBytes(fs10.readFileSync(target)),
+          digest: digestBytes(fs11.readFileSync(target)),
           executable: (stat.mode & 73) !== 0
         });
       } else if (!stat.isDirectory()) {
@@ -12349,7 +13191,7 @@ function captureCandidate(root, scope, environment = []) {
   const values = supplied.toSorted((left, right) => compareCodeUnits2(left.name, right.name)).map(({ name, value }) => ({ name, value, refs: [] }));
   if (values.some(({ value }) => value === null))
     completeness = "uncertain";
-  const headResult = spawnSync5("git", ["rev-parse", "HEAD"], { cwd: checkout, encoding: "utf8" });
+  const headResult = spawnSync6("git", ["rev-parse", "HEAD"], { cwd: checkout, encoding: "utf8" });
   if (headResult.status !== 0 && !/not a git repository/i.test(headResult.stderr ?? ""))
     completeness = "uncertain";
   const head = headResult.status === 0 ? headResult.stdout.trim() : null;
@@ -12489,7 +13331,7 @@ var findingVerificationPasses = (findingCandidateId, evidence) => evidence.statu
 var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
   let root;
   try {
-    root = fs10.realpathSync(checkoutRoot);
+    root = fs11.realpathSync(checkoutRoot);
   } catch {
     return failure2("permission_denied", "checkout root is unavailable");
   }
@@ -12498,23 +13340,23 @@ var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
       continue;
     if (!reference.digest)
       return failure2("invalid_input", "document references require a byte digest");
-    const target = path9.resolve(root, reference.path);
-    if (target !== root && !target.startsWith(`${root}${path9.sep}`))
+    const target = path11.resolve(root, reference.path);
+    if (target !== root && !target.startsWith(`${root}${path11.sep}`))
       return failure2("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
         fields: [
           { path: "contentRefs.path", reason: `${reference.path} is outside the checkout` }
         ]
       });
     try {
-      const below = path9.relative(root, target);
+      const below = path11.relative(root, target);
       let current = root;
-      for (const segment of below.split(path9.sep)) {
+      for (const segment of below.split(path11.sep)) {
         if (!segment)
           continue;
-        current = path9.join(current, segment);
-        const stat = fs10.lstatSync(current);
-        const real = fs10.realpathSync(current);
-        if (real !== root && !real.startsWith(`${root}${path9.sep}`))
+        current = path11.join(current, segment);
+        const stat = fs11.lstatSync(current);
+        const real = fs11.realpathSync(current);
+        if (real !== root && !real.startsWith(`${root}${path11.sep}`))
           return failure2("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
             fields: [
               {
@@ -12530,7 +13372,7 @@ var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
         if (current !== target && !stat.isDirectory())
           return failure2("invalid_input", "document reference ancestor is not a directory");
       }
-      if (digestBytes(fs10.readFileSync(target)) !== reference.digest)
+      if (digestBytes(fs11.readFileSync(target)) !== reference.digest)
         return failure2("permission_denied", "decision document bytes have changed");
     } catch {
       return failure2("invalid_input", "decision document is unavailable");
@@ -12615,7 +13457,35 @@ function evaluateRequirements(task, workspace, capabilities, candidate, checkout
       decisionIds: [],
       reason: "stored policy version is unsupported; reassessment is required"
     }));
+  const ledger = ledgerView(checkoutRoot);
   return (task.policy?.requirements ?? []).map((requirement) => {
+    const derived = derivedRuleStatus(task, requirement, checkoutRoot, ledger);
+    if (derived) {
+      if (derived.met)
+        return {
+          requirementId: requirement.id,
+          status: "satisfied",
+          evidenceIds: [],
+          decisionIds: derived.decisionIds,
+          reason: derived.reason
+        };
+      const waived = requirement.acceptanceAllowed ? applicableDecision(task, workspace, requirement, checkoutRoot) : [];
+      if (waived.length)
+        return {
+          requirementId: requirement.id,
+          status: "accepted_limitation",
+          evidenceIds: [],
+          decisionIds: waived.map((decision) => task.decisions.find((entry) => entry.data === decision).id),
+          reason: "an applicable approved limitation permits the missing evidence"
+        };
+      return {
+        requirementId: requirement.id,
+        status: "unsatisfied",
+        evidenceIds: [],
+        decisionIds: [],
+        reason: derived.reason
+      };
+    }
     const gate = observedGate(requirement) ? evaluateObservedGate(task, requirement, statuses, configFor()) : null;
     if (gate?.satisfied.length)
       return {
@@ -12870,10 +13740,10 @@ Autonomy contract:
   inferred, or guess. Prose is a note: only a configured check the CLI ran
   (\`workit check <name>\`) satisfies a gate; an ad-hoc
   \`workit check -- <cmd>\` never does.
-- Author is not verifier: never record a passing verdict on work your session
-  wrote. The lead starts each verifier with its own session
-  (\`WORKIT_SESSION_ID=<lead>-v<n>\`; Claude Code subagents get one from the
-  hook), and the verifier records \`workit ledger verdict\`.
+- Author is not verifier: your own verdict is \`--self\` (after an observed
+  \`workit check test\`), shown as self-reviewed, never verified. High risk,
+  \`verification: independent\` and merge need a verifier with its own
+  session (\`WORKIT_SESSION_ID=<lead>-v<n>\`; Claude Code subagents get one).
 - A local-commit endpoint does not imply PR readiness, and a local commit alone
   is not evidence of a requested remote push. Before reporting delivery,
   reconcile every requested item and observe it (\`workit verify-delivery\`).
@@ -12886,7 +13756,9 @@ PATH, \`npx -y @brainervirus/workit-cli\`). \`busy\` is retryable
 The task families (task, policy, evidence, finding, decision, worker, state)
 are optional continuity for tracked work; each branch has one implicit task
 that the first recording creates, and a solo edit needs no task. A decision
-records a user choice; it never authorizes an effect.
+records a user choice; it never authorizes an effect. Judge work once with
+\`workit policy assess --judge risk= behavior= product-choice= plan=\`; an
+open choice or missing plan blocks edits until recorded.
 Omit revisions; a revision_conflict means one you passed is stale, so re-read.
 Across repositories, bind each item to its checkout, branch and endpoint,
 resolve competing targets before a mutation, and reconcile an uncertain
@@ -13024,7 +13896,7 @@ var exportDigest = (bundle) => sha256({
   task: bundle.task
 });
 // packages/workit-core/src/core/branch.ts
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 
 // packages/workit-core/src/core/git.ts
 import { execFileSync } from "node:child_process";
@@ -13098,14 +13970,14 @@ var gitContext = (workspaceRoot, paths = []) => {
 import {
   copyFileSync as copyFileSync2,
   cpSync as cpSync2,
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   mkdirSync as mkdirSync2,
   readFileSync as readFileSync3,
   readdirSync as readdirSync3,
   writeFileSync as writeFileSync2
 } from "node:fs";
 import os2 from "node:os";
-import path10 from "node:path";
+import path12 from "node:path";
 
 // packages/workit-core/src/core/boundary.ts
 import { statSync as statSync2 } from "node:fs";
@@ -13164,7 +14036,7 @@ var mergePreset = (preset, input = {}, current = {
     protected: preset === "custom" ? input.protectedNames ?? current.branchPolicy.protected : [...defs.protected]
   };
 };
-var resolveConfigDir = () => process.env.WORKFLOW_TOOLKIT_CONFIG ?? process.env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path10.join(process.env.XDG_CONFIG_HOME || path10.join(os2.homedir(), ".config"), "workit");
+var resolveConfigDir = () => process.env.WORKFLOW_TOOLKIT_CONFIG ?? process.env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path12.join(process.env.XDG_CONFIG_HOME || path12.join(os2.homedir(), ".config"), "workit");
 var migratedDir = null;
 var migrationFailed = false;
 var ensureConfigDir = (dir = resolveConfigDir()) => {
@@ -13174,12 +14046,12 @@ var ensureConfigDir = (dir = resolveConfigDir()) => {
     migratedDir = dir;
     return dir;
   }
-  const legacy = path10.join(process.env.XDG_CONFIG_HOME || path10.join(os2.homedir(), ".config"), "workflow-toolkit");
-  if (!existsSync4(legacy)) {
+  const legacy = path12.join(process.env.XDG_CONFIG_HOME || path12.join(os2.homedir(), ".config"), "workflow-toolkit");
+  if (!existsSync5(legacy)) {
     migratedDir = dir;
     return dir;
   }
-  if (!migrationFailed && existsSync4(dir)) {
+  if (!migrationFailed && existsSync5(dir)) {
     migratedDir = dir;
     return dir;
   }
@@ -13187,9 +14059,9 @@ var ensureConfigDir = (dir = resolveConfigDir()) => {
   mkdirSync2(dir, { recursive: true });
   diagnosticLogger?.info(EVENT.migration, { from: legacy, to: dir });
   for (const entry of readdirSync3(legacy, { withFileTypes: true })) {
-    const src = path10.join(legacy, entry.name);
-    const dest = path10.join(dir, entry.name);
-    if (existsSync4(dest))
+    const src = path12.join(legacy, entry.name);
+    const dest = path12.join(dir, entry.name);
+    if (existsSync5(dest))
       continue;
     try {
       if (entry.isDirectory())
@@ -13260,7 +14132,7 @@ var parseConfigResult = (raw, file) => {
   };
 };
 var readConfigTyped = (dir) => {
-  const file = path10.join(dir ?? configDir(), "config.json");
+  const file = path12.join(dir ?? configDir(), "config.json");
   return parseConfigResult(readSafe(file), file);
 };
 var readConfig = () => {
@@ -13278,7 +14150,7 @@ var mergeConfigValues = (input, current) => ({
 var writeConfig = (config) => {
   const dir = configDir();
   mkdirSync2(dir, { recursive: true });
-  writeFileSync2(path10.join(dir, "config.json"), JSON.stringify(config, null, 2) + `
+  writeFileSync2(path12.join(dir, "config.json"), JSON.stringify(config, null, 2) + `
 `, "utf8");
 };
 var resolveBranchPolicy = (config, workspace) => {
@@ -13317,9 +14189,9 @@ var resolveCommitPolicy = (config, workspace) => {
 };
 
 // packages/workit-core/src/core/workspaces.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 import { readFileSync as readFileSync4, realpathSync as realpathSync3 } from "node:fs";
-import path11 from "node:path";
+import path13 from "node:path";
 var nonBlank = string2().refine((value) => value.trim().length > 0, "must not be blank");
 var branchPreset = custom((value) => typeof value === "string" && Object.hasOwn(PRESETS, value), "unsupported branch preset");
 var commitPreset = custom((value) => typeof value === "string" && COMMIT_PRESETS.includes(value), "unsupported commit preset");
@@ -13372,7 +14244,7 @@ var releaseTrackSchema = object({
       context.addIssue({ code: "custom", path: [field], message: "entries must be unique" });
     }
   }
-  if (track.versionSource.kind === "package-json" && (path11.posix.isAbsolute(track.versionSource.path.replaceAll("\\", "/")) || /^[A-Za-z]:\//u.test(track.versionSource.path.replaceAll("\\", "/")) || track.versionSource.path.replaceAll("\\", "/").split("/").includes(".."))) {
+  if (track.versionSource.kind === "package-json" && (path13.posix.isAbsolute(track.versionSource.path.replaceAll("\\", "/")) || /^[A-Za-z]:\//u.test(track.versionSource.path.replaceAll("\\", "/")) || track.versionSource.path.replaceAll("\\", "/").split("/").includes(".."))) {
     context.addIssue({
       code: "custom",
       path: ["versionSource", "path"],
@@ -13391,6 +14263,7 @@ var workspaceConfigSchema = object({
   }).passthrough().optional(),
   autoApprove: union([boolean2(), array(nonBlank)]).optional(),
   defaultEndpoint: _enum(["commit", "pr"]).optional(),
+  verification: _enum(["self", "independent"]).optional(),
   autonomy: object(Object.fromEntries(["push", "pr", "merge", "release", "rerun"].map((kind) => [
     kind,
     union([boolean2(), literal("verified")]).optional()
@@ -13431,7 +14304,7 @@ var workspacesFileSchema = object({ workspaces: array(workspaceConfigSchema).opt
     names.add(workspace.name);
   }
 });
-var workspacesRevision = (contents) => createHash7("sha256").update(contents ?? "<missing>").digest("hex");
+var workspacesRevision = (contents) => createHash8("sha256").update(contents ?? "<missing>").digest("hex");
 var validateWorkspacesDocument = (parsed, file) => {
   if (!isConfigObject(parsed)) {
     return { status: "malformed", path: file, entries: [], error: `${file} is not a JSON object` };
@@ -13469,7 +14342,7 @@ var validateWorkspacesDocument = (parsed, file) => {
   };
 };
 var readWorkspacesResult = (dir = configDir()) => {
-  const file = path11.join(dir, "workspaces.json");
+  const file = path13.join(dir, "workspaces.json");
   let raw;
   try {
     raw = readFileSync4(file, "utf8");
@@ -13640,7 +14513,7 @@ var runtimeWorkspaceIndexSchema = object({
   workspaces: array(object({ name: nonBlank, glob: nonBlank }).passthrough()).optional()
 }).passthrough();
 var resolveRuntimeWorkspaceCandidate = (cwd, kind) => {
-  const file = path11.join(configDir(), "workspaces.json");
+  const file = path13.join(configDir(), "workspaces.json");
   let raw;
   try {
     raw = readFileSync4(file, "utf8");
@@ -13703,13 +14576,13 @@ var resolveRuntimeWorkspacePolicy = (cwd, kind, requestedProfile) => {
 };
 
 // packages/workit-core/src/core/vcs-config.ts
-import fs11 from "node:fs";
-import path12 from "node:path";
-import { spawnSync as spawnSync6 } from "node:child_process";
-var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path12.join(configDir(), "vcs.json");
+import fs12 from "node:fs";
+import path14 from "node:path";
+import { spawnSync as spawnSync7 } from "node:child_process";
+var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path14.join(configDir(), "vcs.json");
 var vcsCwd = (cwd) => cwd ?? process.env.WORKFLOW_WORKSPACE_ROOT ?? process.cwd();
 var remoteProvider = (cwd) => {
-  const r = spawnSync6("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
+  const r = spawnSync7("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
   if (r.status !== 0)
     return null;
   const url = (r.stdout ?? "").trim();
@@ -13746,7 +14619,7 @@ var remoteEndpoint = (remote) => {
 var configuredSshEndpoint = (host) => {
   if (host.startsWith("-"))
     return null;
-  const resolved = spawnSync6("ssh", ["-G", host], {
+  const resolved = spawnSync7("ssh", ["-G", host], {
     encoding: "utf8",
     timeout: 5000,
     maxBuffer: 1024 * 1024,
@@ -13796,7 +14669,7 @@ var readVcsConfig = () => {
   const file = vcsConfigPath();
   let raw;
   try {
-    raw = fs11.readFileSync(file, "utf8");
+    raw = fs12.readFileSync(file, "utf8");
   } catch {
     return { status: "missing", path: file, config: {} };
   }
@@ -13862,7 +14735,7 @@ function vcsConfig(mode, cwd) {
   const prov = cfg[provider] ?? {};
   const out = {
     ok: true,
-    configPath: path12.resolve(cfgPath),
+    configPath: path14.resolve(cfgPath),
     provider,
     defaultTargetBranch: defaultTarget,
     pr: cfg.pr ?? {},
@@ -13900,7 +14773,7 @@ function mergedPrStyle(limit = 6, cwd) {
 `).filter((l) => l.startsWith("## ")).map((l) => l.trim()),
     descriptionPreview: desc.slice(0, 600)
   });
-  const remoteResult = spawnSync6("git", ["remote", "get-url", "--push", "--all", "origin"], {
+  const remoteResult = spawnSync7("git", ["remote", "get-url", "--push", "--all", "origin"], {
     cwd,
     encoding: "utf8"
   });
@@ -13916,7 +14789,7 @@ function mergedPrStyle(limit = 6, cwd) {
   if (!hostingApiHostMatches(remote, host))
     return { ok: false, error: "PR style target does not match the provider host" };
   if (provider === "gitlab") {
-    const run = (args) => spawnSync6("glab", ["api", ...args], {
+    const run = (args) => spawnSync7("glab", ["api", ...args], {
       cwd,
       encoding: "utf8",
       env
@@ -13936,7 +14809,7 @@ function mergedPrStyle(limit = 6, cwd) {
       });
     }
   } else if (provider === "github") {
-    const r = spawnSync6("gh", [
+    const r = spawnSync7("gh", [
       "pr",
       "list",
       "--repo",
@@ -14006,356 +14879,85 @@ var validateBranchNamePolicy = (name, policy, source) => {
   }
   return { ok: true };
 };
-var branchPolicySnapshotFor = (workspaceRoot) => {
-  const resolved = effectiveWorkspacePolicy(workspaceRoot, "branch");
-  const branchPolicy = resolved.branchPolicy;
-  const source = resolved.provenance.branchPolicy;
-  const allowed = branchPolicy.allowed.map((pattern) => `${pattern.source}/${pattern.flags}`).toSorted();
-  const protectedRefs = [...branchPolicy.protected].map((name) => name.toLowerCase()).toSorted();
-  const fingerprint = createHash8("sha256").update(JSON.stringify({ allowed, protectedRefs, source })).digest("hex");
-  return {
-    branchPolicy,
-    namePolicy: { allowed: branchPolicy.allowed, protected: branchPolicy.protected },
-    source,
-    fingerprint
-  };
-};
-var validateBranchNameFor = (workspaceRoot, name) => {
-  try {
-    const resolved = branchPolicySnapshotFor(workspaceRoot);
-    return validateBranchNamePolicy(name, resolved.namePolicy, resolved.source);
-  } catch (error) {
-    const correction = "repair or select a valid workspace policy before creating a branch";
-    return {
-      ok: false,
-      rule: "policy_unavailable",
-      source: "workspaces.json",
-      attempted: name,
-      correction,
-      error: `policy_unavailable: cannot validate branch ${JSON.stringify(name)} because ${error instanceof Error ? error.message : String(error)}; ${correction}`
-    };
-  }
-};
-var resolveBranchPolicyFor = (workspaceRoot, profileName) => effectiveWorkspacePolicy(workspaceRoot, "branch", profileName).branchPolicy;
-
-// packages/workit-core/src/core/route-intent.ts
-var shellBranchTarget = (command) => {
-  if (!command.trim() || /[\r\n;&|<>`'"$()\\*?{}~!#]/u.test(command) || command.includes("[") || command.includes("]"))
-    return null;
-  const args = command.trim().split(/\s+/u);
-  if (args[0] !== "git")
-    return null;
-  const option = args[2];
-  const target = args[1] === "switch" && ["-c", "--create", "-C", "--force-create"].includes(option ?? "") && (args.length === 4 || args.length === 5) ? args[3] : args[1] === "checkout" && ["-b", "-B"].includes(option ?? "") && (args.length === 4 || args.length === 5) ? args[3] : args[1] === "branch" && (args.length === 3 || args.length === 4) ? args[2] : null;
-  return target && !target.startsWith("-") ? target : null;
-};
-var shellBranchPolicyViolation = (root, command) => {
-  const target = shellBranchTarget(command);
-  return target === null ? null : validateBranchNameFor(root, target);
-};
-// packages/workit-core/src/core/task-engine.ts
-import { realpathSync as realpathSync4 } from "node:fs";
-
-// packages/workit-core/src/core/policy-resolver.ts
-var resolverInputSchema = object({
-  intent: intentSchema,
-  assessment: assessmentSchema,
-  constraints: array(constraintSchema),
-  prior: object({
-    decisions: array(decisionSchema),
-    findings: array(findingSchema),
-    requirements: array(requirementSchema)
-  }).strict(),
-  preferences: object({ fast: boolean2().optional(), thorough: boolean2().optional() }).strict().optional()
-}).strict();
-var compareCodeUnits3 = (left, right) => {
-  const length = Math.min(left.length, right.length);
-  for (let index = 0;index < length; index += 1) {
-    const difference = left.charCodeAt(index) - right.charCodeAt(index);
-    if (difference !== 0)
-      return difference;
-  }
-  return left.length - right.length;
-};
-var stableUnique = (values) => [...new Set(values)].toSorted(compareCodeUnits3);
-var stableList = (values) => [...values].toSorted((left, right) => compareCodeUnits3(canonicalJson(left), canonicalJson(right)));
-var normalizedScope = (scope) => ({
-  description: scope.description,
-  paths: stableUnique(scope.paths),
-  exclusions: stableUnique(scope.exclusions)
-});
-var normalizedRefList = (values) => stableList(values);
-var normalizeAssessment = (assessment) => ({
-  facts: stableList(assessment.facts.map((fact) => ({ ...fact, refs: normalizedRefList(fact.refs) }))),
-  signals: Object.fromEntries(Object.entries(assessment.signals).map(([name, signal]) => [
-    name,
-    { ...signal, refs: normalizedRefList(signal.refs) }
-  ])),
-  consequences: stableList(assessment.consequences.map((consequence) => ({
-    ...consequence,
-    fact: { ...consequence.fact, refs: normalizedRefList(consequence.fact.refs) }
-  }))),
-  verification: stableList(assessment.verification.map((verification) => ({
-    ...verification,
-    scope: normalizedScope(verification.scope),
-    availableChecks: normalizedRefList(verification.availableChecks),
-    gaps: stableUnique(verification.gaps)
-  })))
-});
-var normalizeConstraint = (constraint) => ({
-  ...constraint,
-  source: constraint.source,
-  requires: stableList(constraint.requires.map((requirement) => ({
-    ...requirement,
-    scope: normalizedScope(requirement.scope),
-    refs: normalizedRefList(requirement.refs)
-  })))
-});
-var normalizeDecision = (decision) => ({
-  ...decision,
-  binding: {
-    ...decision.binding,
-    scope: normalizedScope(decision.binding.scope),
-    contentRefs: normalizedRefList(decision.binding.contentRefs)
-  },
-  requirementIds: stableUnique(decision.requirementIds)
-});
-var normalizeIntent = (intent) => ({
-  ...intent,
-  scope: normalizedScope(intent.scope),
-  authorityRefs: normalizedRefList(intent.authorityRefs)
-});
-var normalizePrior = (prior) => ({
-  decisions: stableList(prior.decisions.map(normalizeDecision)),
-  findings: stableList(prior.findings.map((finding) => ({
-    ...finding,
-    scope: normalizedScope(finding.scope),
-    refs: normalizedRefList(finding.refs),
-    resolution: finding.resolution ? {
-      ...finding.resolution,
-      evidenceIds: stableUnique(finding.resolution.evidenceIds),
-      decisionIds: stableUnique(finding.resolution.decisionIds)
-    } : null
-  }))),
-  requirements: stableList(prior.requirements.map((requirement) => ({
-    ...requirement,
-    scope: normalizedScope(requirement.scope)
-  })))
-});
-var invalidFields = (error) => ({
-  fields: error.issues.map((issue) => ({
-    path: issue.code === "unrecognized_keys" ? issue.keys.join(".") : issue.path.join("."),
-    reason: issue.message
-  }))
-});
-function normalizeResolverInput(input) {
-  const parsed = resolverInputSchema.safeParse(input);
-  if (!parsed.success)
-    return failure2("invalid_input", "resolver input is invalid", invalidFields(parsed.error));
-  const value = parsed.data;
-  const signals = value.assessment.signals;
-  if (signals.behaviorChange.value === true && signals.mechanicalLowRisk.value === true)
-    return failure2("invalid_input", "behavioral change cannot be wholly mechanical", {
-      fields: [
-        {
-          path: "assessment.signals",
-          reason: "contradictory behaviorChange and mechanicalLowRisk"
-        }
-      ]
-    });
-  const ids = value.constraints.map((constraint) => constraint.id);
-  if (new Set(ids).size !== ids.length)
-    return failure2("invalid_input", "constraint IDs must be unique", {
-      fields: [{ path: "constraints", reason: "duplicate constraint id" }]
-    });
-  if (value.preferences?.fast && value.preferences.thorough)
-    return failure2("invalid_input", "fast and thorough preferences contradict", {
-      fields: [{ path: "preferences", reason: "fast and thorough cannot both be enabled" }]
-    });
-  const normalized = {
-    intent: normalizeIntent(value.intent),
-    assessment: normalizeAssessment(value.assessment),
-    constraints: stableList(value.constraints.map(normalizeConstraint)),
-    prior: normalizePrior(value.prior),
-    ...value.preferences ? { preferences: { ...value.preferences } } : {},
-    policyVersion: POLICY_VERSION
-  };
-  return success(null, null, normalized);
-}
-var requirement = (spec) => ({
-  ...spec,
-  id: requirementId({
-    ruleId: spec.ruleId,
-    scope: spec.scope,
-    satisfaction: spec.satisfaction,
-    before: spec.before,
-    dependentAction: spec.dependentAction
-  })
-});
-var signalReason = (input, name) => input.assessment.signals[name].reason;
-function resolveRequirements(input) {
-  const { signals } = input.assessment;
-  const scope = input.intent.scope;
-  const requirements = [];
-  const hasUnknownSignal = Object.values(signals).some((signal) => signal.value === "unknown");
-  const hasUnknownFact = [
-    ...input.assessment.facts,
-    ...input.assessment.consequences.map(({ fact }) => fact)
-  ].some((fact) => fact.basis === "unknown");
-  if (hasUnknownSignal || hasUnknownFact)
-    requirements.push(requirement({
-      ruleId: "consequential-unknown",
-      dimension: "investigation",
-      scope,
-      reason: `Resolve consequential uncertainty before the dependent action: ${[
-        ...Object.entries(signals).filter(([, signal]) => signal.value === "unknown").map(([name]) => name),
-        ...hasUnknownFact ? ["unknown fact"] : []
-      ].join(", ")}`,
-      satisfaction: "An observed or inferred fact resolves the uncertainty and records its supporting references.",
-      before: "dependent_action",
-      dependentAction: null,
-      acceptanceAllowed: false
-    }));
-  if (signals.productChoiceOpen.value === true)
-    requirements.push(requirement({
-      ruleId: "product-decision",
-      dimension: "decisions",
-      scope,
-      reason: `A consequential product choice remains open: ${signalReason(input, "productChoiceOpen")}`,
-      satisfaction: "Present the material alternatives and record the user's decision before the dependent action.",
-      before: "dependent_action",
-      dependentAction: null,
-      acceptanceAllowed: false
-    }));
-  const independentBehaviorReview = input.preferences?.thorough === true || input.assessment.consequences.some((consequence) => ["security", "data", "public_contract", "operations"].includes(consequence.area));
-  if (signals.behaviorChange.value === true)
-    requirements.push(requirement({
-      ruleId: "behavioral-verification",
-      dimension: "testing",
-      scope,
-      reason: `Behavior, side effects, permissions, or data handling may change: ${signalReason(input, "behaviorChange")}`,
-      satisfaction: "A useful behavioral check passes against the affected behavior and current candidate.",
-      before: "close",
-      dependentAction: null,
-      acceptanceAllowed: false
-    }), requirement({
-      ruleId: independentBehaviorReview ? "fresh-context-review" : "self-review",
-      dimension: "review",
-      scope,
-      reason: independentBehaviorReview ? "Consequential behavior or the thorough preference requires fresh-context review." : "Bounded behavior changes use self-review unless consequential risks or trusted rules require more.",
-      satisfaction: independentBehaviorReview ? "A separate review context examines the current candidate and records its result." : "The lead reviews the resulting diff and records the relevant scope and checks.",
-      before: "close",
-      dependentAction: null,
-      acceptanceAllowed: !independentBehaviorReview
-    }));
-  else if (signals.mechanicalLowRisk.value === true)
-    requirements.push(requirement({
-      ruleId: "mechanical-existing-checks",
-      dimension: "verification",
-      scope,
-      reason: `The change is demonstrably mechanical and low-risk: ${signalReason(input, "mechanicalLowRisk")}`,
-      satisfaction: "Run the relevant existing checks for affected consumers; do not add tautological tests.",
-      before: "close",
-      dependentAction: null,
-      acceptanceAllowed: true
-    }), requirement({
-      ruleId: input.preferences?.thorough ? "fresh-context-review" : "self-review",
-      dimension: "review",
-      scope,
-      reason: input.preferences?.thorough ? "The thorough preference upgrades mechanical self-review to fresh-context review." : "Mechanical low-risk work uses self-review rather than mandatory fresh-context review.",
-      satisfaction: input.preferences?.thorough ? "A separate review context examines the current candidate and records its result." : "The lead reviews the resulting diff and records the relevant scope and checks.",
-      before: "close",
-      dependentAction: null,
-      acceptanceAllowed: !input.preferences?.thorough
-    }));
-  if (signals.behaviorChange.value === true || signals.mechanicalLowRisk.value === true)
-    requirements.push(requirement({
-      ruleId: "pre-pr-cleanup",
-      dimension: "verification",
-      scope,
-      reason: "Implementation output must be deslopped before it is delivered.",
-      satisfaction: "Run the workit-deslop pass and record passing check evidence, or record an approved limitation decision waiving cleanup.",
-      before: "dependent_action",
-      dependentAction: "hosting.pull_request",
-      acceptanceAllowed: true
-    }));
-  if (signals.durableAgreementNeeded.value === true)
-    requirements.push(requirement({
-      ruleId: "durable-spec",
-      dimension: "artifacts",
-      scope,
-      reason: `The work needs a durable agreement about intended behavior: ${signalReason(input, "durableAgreementNeeded")}`,
-      satisfaction: "Record the agreed behavior in a durable specification before implementation writes.",
-      before: "write",
-      dependentAction: null,
-      acceptanceAllowed: true
-    }));
-  if (signals.coordinationPlanNeeded.value === true)
-    requirements.push(requirement({
-      ruleId: "coordination-plan",
-      dimension: "continuity",
-      scope,
-      reason: `Dependencies, sequencing, or resumption need durable coordination: ${signalReason(input, "coordinationPlanNeeded")}`,
-      satisfaction: "Record useful sequencing, dependencies, and the next action in a compact plan.",
-      before: "dependent_action",
-      dependentAction: null,
-      acceptanceAllowed: true
-    }));
-  if (signals.helperUseful.value === true && !input.preferences?.fast)
-    requirements.push(requirement({
-      ruleId: "helper-usefulness",
-      dimension: "delegation",
-      scope,
-      reason: `Independent judgment or investigation justifies a scoped helper: ${signalReason(input, "helperUseful")}`,
-      satisfaction: "Use a bounded helper only for the independent objective and reconcile its result.",
-      before: "dependent_action",
-      dependentAction: null,
-      acceptanceAllowed: true
-    }));
-  for (const constraint of input.constraints)
-    for (const obligation of constraint.requires) {
-      const dimension = obligation.method ?? (obligation.kind === "check" ? "verification" : obligation.kind === "decision" ? "decisions" : "challenge");
-      requirements.push(requirement({
-        ruleId: `project-constraint:${constraint.id}:${obligation.kind}:${sha256({
-          kind: obligation.kind,
-          scope: normalizedScope(obligation.scope),
-          refs: normalizedRefList(obligation.refs),
-          method: obligation.method,
-          before: obligation.before,
-          dependentAction: obligation.dependentAction
-        })}`,
-        dimension,
-        scope: obligation.scope,
-        reason: `${constraint.kind} constraint requires ${obligation.kind}: ${constraint.statement}`,
-        satisfaction: `Satisfy the constraint obligation using its referenced ${obligation.kind}.`,
-        before: obligation.before,
-        dependentAction: obligation.dependentAction,
-        acceptanceAllowed: constraint.acceptanceAllowed && obligation.kind !== "decision"
-      }));
-    }
-  const seen = new Set;
-  return requirements.filter((item) => {
-    if (seen.has(item.id))
-      return false;
-    seen.add(item.id);
-    return true;
-  });
-}
+var branchPolicySnapshotFor = (workspaceRoot) => {
+  const resolved = effectiveWorkspacePolicy(workspaceRoot, "branch");
+  const branchPolicy = resolved.branchPolicy;
+  const source = resolved.provenance.branchPolicy;
+  const allowed = branchPolicy.allowed.map((pattern) => `${pattern.source}/${pattern.flags}`).toSorted();
+  const protectedRefs = [...branchPolicy.protected].map((name) => name.toLowerCase()).toSorted();
+  const fingerprint = createHash9("sha256").update(JSON.stringify({ allowed, protectedRefs, source })).digest("hex");
+  return {
+    branchPolicy,
+    namePolicy: { allowed: branchPolicy.allowed, protected: branchPolicy.protected },
+    source,
+    fingerprint
+  };
+};
+var validateBranchNameFor = (workspaceRoot, name) => {
+  try {
+    const resolved = branchPolicySnapshotFor(workspaceRoot);
+    return validateBranchNamePolicy(name, resolved.namePolicy, resolved.source);
+  } catch (error) {
+    const correction = "repair or select a valid workspace policy before creating a branch";
+    return {
+      ok: false,
+      rule: "policy_unavailable",
+      source: "workspaces.json",
+      attempted: name,
+      correction,
+      error: `policy_unavailable: cannot validate branch ${JSON.stringify(name)} because ${error instanceof Error ? error.message : String(error)}; ${correction}`
+    };
+  }
+};
+var resolveBranchPolicyFor = (workspaceRoot, profileName) => effectiveWorkspacePolicy(workspaceRoot, "branch", profileName).branchPolicy;
+
+// packages/workit-core/src/core/route-intent.ts
+var shellBranchTarget = (command) => {
+  if (!command.trim() || /[\r\n;&|<>`'"$()\\*?{}~!#]/u.test(command) || command.includes("[") || command.includes("]"))
+    return null;
+  const args = command.trim().split(/\s+/u);
+  if (args[0] !== "git")
+    return null;
+  const option = args[2];
+  const target = args[1] === "switch" && ["-c", "--create", "-C", "--force-create"].includes(option ?? "") && (args.length === 4 || args.length === 5) ? args[3] : args[1] === "checkout" && ["-b", "-B"].includes(option ?? "") && (args.length === 4 || args.length === 5) ? args[3] : args[1] === "branch" && (args.length === 3 || args.length === 4) ? args[2] : null;
+  return target && !target.startsWith("-") ? target : null;
+};
+var shellBranchPolicyViolation = (root, command) => {
+  const target = shellBranchTarget(command);
+  return target === null ? null : validateBranchNameFor(root, target);
+};
+// packages/workit-core/src/core/task-engine.ts
+import { realpathSync as realpathSync4 } from "node:fs";
+
+// packages/workit-core/src/core/policy-resolver.ts
 function resolvePolicy(input) {
-  const normalized = normalizeResolverInput(input);
-  if (!normalized.ok)
-    return normalized;
-  const requirements = resolveRequirements(normalized.data);
+  const ids = input.constraints.map((constraint) => constraint.id);
+  if (new Set(ids).size !== ids.length)
+    return failure2("invalid_input", "constraint IDs must be unique", {
+      fields: [{ path: "constraints", reason: "duplicate constraint id" }]
+    });
   const policy = {
     policyVersion: POLICY_VERSION,
-    inputDigest: sha256(canonicalJson(normalized.data)),
-    requirements
+    inputDigest: sha256(canonicalJson({
+      judgment: input.judgment,
+      scope: input.intent.scope,
+      constraints: input.constraints,
+      verification: input.verification ?? "self",
+      policyVersion: POLICY_VERSION
+    })),
+    requirements: deriveRequirements(input.judgment, input.intent.scope, input.constraints, input.verification)
   };
   const parsed = policySchema.safeParse(policy);
   if (!parsed.success)
-    return failure2("invalid_input", "resolved policy is invalid", invalidFields(parsed.error));
+    return failure2("invalid_input", "resolved policy is invalid", {
+      fields: parsed.error.issues.map((issue) => ({
+        path: issue.path.join("."),
+        reason: issue.message
+      }))
+    });
   return success(null, null, parsed.data);
 }
+var compareCodeUnits3 = (left, right) => left < right ? -1 : left > right ? 1 : 0;
 function diffPolicy(previous, next, reason, now) {
   if (!policySchema.safeParse(previous).success && previous !== null)
     throw new TypeError("previous policy is invalid");
@@ -14383,7 +14985,247 @@ function diffPolicy(previous, next, reason, now) {
   return parsed.data;
 }
 
+// packages/workit-core/src/core/policy/judgment.ts
+var isObject6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var squash = (key) => key.toLowerCase().replace(/[_-]/g, "");
+var ALIASES = {
+  riskTier: ["risktier", "risk", "risklevel", "tier"],
+  behaviorChange: ["behaviorchange", "behavior", "behaviour", "behaviourchange"],
+  productChoiceOpen: ["productchoiceopen", "openproductchoice", "productchoice", "openchoice"],
+  needsPlan: ["needsplan", "plan", "needsspec", "spec"],
+  note: ["note", "notes", "reason", "why"],
+  refs: ["refs", "ref", "references"]
+};
+var LEGACY_KEYS = new Set(["assessment", "facts", "signals", "consequences", "verification"]);
+var RISK = {
+  trivial: "trivial",
+  low: "trivial",
+  minor: "trivial",
+  mechanical: "trivial",
+  none: "trivial",
+  normal: "normal",
+  medium: "normal",
+  med: "normal",
+  moderate: "normal",
+  high: "high",
+  critical: "high",
+  major: "high"
+};
+var YES = new Set(["true", "yes", "y", "1", "on"]);
+var NO = new Set(["false", "no", "n", "0", "off", "none"]);
+var flag = (value, unknownAs) => {
+  if (typeof value === "boolean")
+    return { ok: true, value };
+  if (typeof value === "number" && (value === 0 || value === 1))
+    return { ok: true, value: value === 1 };
+  if (typeof value !== "string")
+    return { ok: false };
+  const text = value.trim().toLowerCase();
+  if (YES.has(text))
+    return { ok: true, value: true };
+  if (NO.has(text))
+    return { ok: true, value: false };
+  if (text === "unknown" || text === "maybe")
+    return { ok: true, value: unknownAs };
+  return { ok: false };
+};
+var fromLegacy = (raw, previous) => {
+  const source = isObject6(raw.assessment) ? raw.assessment : raw;
+  const signals = isObject6(source.signals) ? source.signals : {};
+  const value = (name) => isObject6(signals[name]) ? signals[name].value : undefined;
+  const known = (name, fallback) => typeof value(name) === "boolean" ? value(name) : fallback;
+  const behaviorChange = known("behaviorChange", previous?.behaviorChange ?? false);
+  const consequences = Array.isArray(source.consequences) ? source.consequences : [];
+  const freshReview = value("behaviorChange") === true && consequences.some((item) => isObject6(item) && ["security", "data", "public_contract", "operations"].includes(String(item.area)));
+  return {
+    riskTier: freshReview ? "high" : value("mechanicalLowRisk") === true && !behaviorChange ? "trivial" : "normal",
+    behaviorChange,
+    productChoiceOpen: known("productChoiceOpen", previous?.productChoiceOpen ?? false),
+    needsPlan: known("durableAgreementNeeded", previous?.needsPlan ?? false) || value("coordinationPlanNeeded") === true
+  };
+};
+var DEFAULT = {
+  riskTier: "normal",
+  behaviorChange: false,
+  productChoiceOpen: false,
+  needsPlan: false,
+  note: null,
+  refs: []
+};
+function normalizeJudgment(raw, previous) {
+  const input = isObject6(raw) ? raw : {};
+  const legacy = Object.keys(input).some((key) => LEGACY_KEYS.has(key));
+  const base = { ...DEFAULT, ...previous, refs: [...previous?.refs ?? []] };
+  const judgment = legacy ? { ...base, ...fromLegacy(input, previous) } : { ...base };
+  const ignored = [];
+  const fields = [];
+  for (const [key, value] of Object.entries(input)) {
+    if (LEGACY_KEYS.has(key))
+      continue;
+    const name = Object.keys(ALIASES).find((field) => ALIASES[field].includes(squash(key)));
+    if (!name) {
+      ignored.push(key);
+      continue;
+    }
+    if (name === "riskTier") {
+      const tier = typeof value === "string" ? RISK[value.trim().toLowerCase()] : undefined;
+      if (tier)
+        judgment.riskTier = tier;
+      else
+        fields.push({ path: key, reason: "expected trivial|normal|high (or low|medium)" });
+    } else if (name === "note") {
+      judgment.note = typeof value === "string" && value.trim() ? value.trim() : null;
+    } else if (name === "refs") {
+      const items = Array.isArray(value) ? value : [value];
+      judgment.refs.push(...items.filter((item) => item !== null && item !== "").map(refOf));
+    } else {
+      if (name === "needsPlan" && typeof value === "string" && !flag(value, false).ok && value.trim()) {
+        judgment.needsPlan = true;
+        judgment.refs.push(refOf(value.trim()));
+        continue;
+      }
+      const parsed = flag(value, name === "behaviorChange");
+      if (parsed.ok)
+        judgment[name] = parsed.value;
+      else
+        fields.push({ path: key, reason: "expected true|false (yes|no accepted)" });
+    }
+  }
+  if (fields.length)
+    return failure2("invalid_input", "judgment values are invalid", { fields });
+  const seen = new Set;
+  judgment.refs = judgment.refs.filter((ref) => {
+    const key = JSON.stringify(ref);
+    return seen.has(key) ? false : (seen.add(key), true);
+  });
+  const parsed = judgmentSchema.safeParse(judgment);
+  if (!parsed.success)
+    return failure2("invalid_input", "judgment is invalid", {
+      fields: parsed.error.issues.map((issue) => ({
+        path: issue.path.join("."),
+        reason: issue.message
+      }))
+    });
+  return success(null, null, { judgment: parsed.data, ignored, legacy });
+}
+
+// packages/workit-core/src/autonomy.ts
+import os3 from "node:os";
+import path15 from "node:path";
+
+// packages/workit-core/src/core/safe-write.ts
+import {
+  closeSync as closeSync2,
+  fchmodSync,
+  fsyncSync,
+  lstatSync as lstatSync3,
+  mkdirSync as mkdirSync3,
+  openSync as openSync2,
+  renameSync as renameSync2,
+  unlinkSync,
+  writeFileSync as writeFileSync3
+} from "node:fs";
+function writeFileExclusive(file, content, mode) {
+  try {
+    writeFileSync3(file, content, { encoding: "utf8", flag: "wx", mode });
+    return "created";
+  } catch (err) {
+    if (err.code === "EEXIST")
+      return "preserved";
+    throw err;
+  }
+}
+
+// packages/workit-core/src/autonomy.ts
+var accountHome = () => {
+  try {
+    return os3.userInfo().homedir;
+  } catch {
+    return os3.homedir();
+  }
+};
+var grantsHome = { resolve: accountHome };
+var grantsDir = () => path15.join(grantsHome.resolve(), ".config", "workit");
+var grantsOverride = () => {
+  const configured = path15.resolve(resolveConfigDir());
+  return configured === path15.resolve(grantsDir()) ? null : `the config directory is redirected to ${configured} (WORKFLOW_TOOLKIT_CONFIG, WORKFLOW_TOOLKIT_CONFIG_DIR or XDG_CONFIG_HOME); grants are read only from ${path15.join(grantsDir(), "workspaces.json")}, so the D4 defaults apply`;
+};
+var GRANT_KINDS = ["push", "pr", "merge", "release", "rerun"];
+var DEFAULT_GRANTS = Object.freeze({
+  push: true,
+  pr: true,
+  merge: false,
+  release: false,
+  rerun: true
+});
+var DEFAULT_ENDPOINT = "commit";
+var DEFAULT_VERIFICATION = "self";
+var verificationOf = (entry) => entry?.verification === "independent" ? "independent" : "self";
+var endpointOf = (entry) => entry?.defaultEndpoint === "pr" ? "pr" : "commit";
+var isGrantValue = (value) => value === true || value === false || value === "verified";
+var normalized = (kind, value) => value === "verified" && kind !== "merge" ? true : value;
+var fromAutoApprove = (value) => {
+  if (value === true)
+    return { push: true, pr: true, merge: "verified" };
+  if (!Array.isArray(value))
+    return null;
+  const grants = {};
+  for (const item of value)
+    if (item === "push" || item === "pr")
+      grants[item] = true;
+    else if (item === "merge")
+      grants.merge = "verified";
+  return Object.keys(grants).length > 0 ? grants : null;
+};
+function configuredGrants(entry) {
+  const record = entry ?? {};
+  const raw = record.autonomy;
+  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+    const grants = {};
+    for (const kind of GRANT_KINDS) {
+      const value = raw[kind];
+      if (isGrantValue(value))
+        grants[kind] = normalized(kind, value);
+    }
+    return { grants, source: "autonomy" };
+  }
+  const legacy = fromAutoApprove(record.autoApprove);
+  return legacy ? { grants: legacy, source: "autoApprove" } : { grants: {}, source: "default" };
+}
+function resolveAutonomy(cwd) {
+  const override = grantsOverride();
+  if (override)
+    return {
+      workspace: null,
+      grants: { ...DEFAULT_GRANTS },
+      configured: [],
+      source: "default",
+      accountConfigured: false,
+      defaultEndpoint: DEFAULT_ENDPOINT,
+      verification: DEFAULT_VERIFICATION,
+      note: override
+    };
+  const workspace = resolveWorkspaceFrom(cwd, grantsDir(), process.env.WORKFLOW_WORKSPACE_NAME?.trim() || undefined);
+  const { grants, source } = configuredGrants(workspace);
+  return {
+    workspace: workspace?.name ?? null,
+    grants: { ...DEFAULT_GRANTS, ...grants },
+    configured: GRANT_KINDS.filter((kind) => grants[kind] !== undefined),
+    source,
+    accountConfigured: Boolean(workspace?.vcs?.account),
+    defaultEndpoint: endpointOf(workspace),
+    verification: verificationOf(workspace)
+  };
+}
+
 // packages/workit-core/src/core/task-engine.ts
+var workspaceVerification = (root) => {
+  try {
+    return resolveAutonomy(root).verification;
+  } catch {
+    return "self";
+  }
+};
 var provenance = (context, kind = context.provenanceKind ?? "host_observed") => ({
   kind,
   host: context.caller.host,
@@ -14576,22 +15418,7 @@ var mapRef = (ref, ids) => {
     return ref;
   return { ...ref, id: ids.get(ref.id) ?? ref.id };
 };
-var portableRefs = (refs) => refs.filter((ref) => ref.kind === "file" || ref.kind === "record");
 var portableRef = (ref) => ref && (ref.kind === "file" || ref.kind === "record") ? ref : null;
-var portableFact = (fact) => {
-  const refs = portableRefs(fact.refs);
-  return fact.basis === "observed" && refs.length === 0 ? { ...fact, basis: "unknown", refs } : { ...fact, refs };
-};
-var portableSignal = (signal) => {
-  const refs = portableRefs(signal.refs);
-  return signal.basis === "observed" && refs.length === 0 ? {
-    ...signal,
-    value: "unknown",
-    basis: "unknown",
-    reason: "portable supporting reference was removed",
-    refs
-  } : { ...signal, refs };
-};
 var importedProvenance = (context) => ({
   kind: "imported",
   host: context.caller.host,
@@ -14603,18 +15430,6 @@ var portableTask = (task) => {
   if (typeof stripped !== "object" || stripped === null || Array.isArray(stripped))
     throw new TypeError("portable task rewrite produced a non-record");
   const clone = structuredClone(stripped);
-  const demote = (facts, signals, consequences) => {
-    for (const fact of facts)
-      Object.assign(fact, portableFact(fact));
-    for (const name of Object.keys(signals)) {
-      const signal = signals[name];
-      Object.assign(signal, portableSignal(signal));
-    }
-    for (const consequence of consequences)
-      Object.assign(consequence.fact, portableFact(consequence.fact));
-  };
-  for (const entry of clone.assessments)
-    demote(entry.data.facts, entry.data.signals, entry.data.consequences);
   clone.candidates = [];
   return clone;
 };
@@ -14631,6 +15446,7 @@ var importedTask = (source, bundle, destinationWorkspaceId, context, timestamp)
   for (const entry of [
     source.intent,
     ...source.assessments,
+    ...source.judgments ?? [],
     ...source.evidence,
     ...source.decisions,
     ...source.findings,
@@ -14654,9 +15470,16 @@ var importedTask = (source, bundle, destinationWorkspaceId, context, timestamp)
       id: fresh(entry.id),
       recordedAt: timestamp,
       provenance: imported,
-      data: rewriteRecordRefs(data, assessmentSchema, remap)
+      data: rewriteRecordRefs(data, legacyAssessmentSchema, remap)
     };
   });
+  const judgments = source.judgments?.map((entry) => ({
+    ...entry,
+    id: fresh(entry.id),
+    recordedAt: timestamp,
+    provenance: imported,
+    data: rewriteRecordRefs(entry.data, judgmentSchema, remap)
+  }));
   const evidence = source.evidence.map((entry) => ({
     ...entry,
     id: fresh(entry.id),
@@ -14724,6 +15547,7 @@ var importedTask = (source, bundle, destinationWorkspaceId, context, timestamp)
     status: "paused",
     closure: null,
     assessments,
+    ...judgments ? { judgments } : {},
     evidence,
     decisions: decisions.map((entry) => {
       const data = rewriteRecordRefs(entry.data, decisionSchema, remap);
@@ -14793,7 +15617,8 @@ class WorkitCore {
   retryOmittedRevisions(request, run) {
     return retryFilledRevisions(filledRevisions(request), run);
   }
-  implicitTask(family, request) {
+  implicitTask(family, raw) {
+    const request = normalizeOperationInput(family, raw, this.context.caller.host);
     if (typeof request !== "object" || request === null || Array.isArray(request))
       return success(null, null, request);
     const value = request;
@@ -15047,7 +15872,11 @@ class WorkitCore {
     if ((this.context.workerId ?? null) !== null)
       return failure2("permission_denied", "helpers cannot change task requirements");
     this.fillRevisions(input, task.data);
-    const resolved = this.resolve(task.data, input.assessment);
+    const judged = normalizeJudgment(input.judgment, latestJudgment(task.data));
+    if (!judged.ok)
+      return judged;
+    const judgment = judged.data.judgment;
+    const resolved = this.resolve(task.data, judgment);
     if (!resolved.ok)
       return resolved;
     if (input.action === "preview")
@@ -15058,16 +15887,17 @@ class WorkitCore {
       if (current.status === "closed")
         return failure2("invalid_transition", "closed task cannot be assessed");
       const nextChange = diffPolicy(current.policy, resolved.data, "policy reassessed", mutation.now);
-      const assessment = {
+      const entry = {
         id: newId(),
         recordedAt: mutation.now,
         provenance: provenance(this.context),
-        data: input.assessment
+        data: judgment
       };
       const next = {
         ...current,
         constraints: this.context.constraints,
-        assessments: [...current.assessments, assessment],
+        judgments: [...current.judgments ?? [], entry],
+        critical: [...new Set([...current.critical ?? [], "judgments"])],
         policy: resolved.data,
         policyChanges: nextChange ? [...current.policyChanges, nextChange] : current.policyChanges
       };
@@ -15269,9 +16099,14 @@ class WorkitCore {
         return workspace;
       if (!workspace.data)
         return failure2("not_found", "workspace not found");
-      if (input.binding.taskId !== task.data.id || input.binding.workspaceId !== workspace.data.id)
+      const binding = {
+        ...input.binding,
+        taskId: input.binding.taskId ?? task.data.id,
+        workspaceId: input.binding.workspaceId ?? workspace.data.id
+      };
+      if (binding.taskId !== task.data.id || binding.workspaceId !== workspace.data.id)
         return failure2("invalid_input", "decision task or workspace binding is invalid");
-      const content = verifyDecisionContentAtRoot(this.store.root, input.binding);
+      const content = verifyDecisionContentAtRoot(this.store.root, binding);
       if (!content.ok)
         return content;
       const knownRequirements = new Set(task.data.policy?.requirements.map((item) => item.id) ?? []);
@@ -15279,7 +16114,7 @@ class WorkitCore {
         return failure2("invalid_input", "decision references an unknown requirement");
       const base = {
         purpose: input.purpose,
-        binding: input.binding,
+        binding,
         response: input.response,
         requirementIds: input.requirementIds,
         revoked: null
@@ -15638,16 +16473,12 @@ class WorkitCore {
       now: trustedNow(this.context)
     });
   }
-  resolve(task, assessment) {
+  resolve(task, judgment) {
     return resolvePolicy({
       intent: task.intent.data,
-      assessment,
+      judgment,
       constraints: this.context.constraints,
-      prior: {
-        decisions: task.decisions.filter((entry) => entry.provenance.kind !== "imported").map((entry) => entry.data),
-        findings: task.findings.filter((entry) => entry.provenance.kind !== "imported").map((entry) => entry.data),
-        requirements: task.origin || task.policy === null ? [] : task.policy.requirements
-      }
+      verification: workspaceVerification(this.context.root)
     });
   }
   summary(task) {
@@ -15973,9 +16804,9 @@ class WorkitCore {
   }
 }
 // packages/workit-core/src/core/repo-context.ts
-import { spawnSync as spawnSync7 } from "node:child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync5, readdirSync as readdirSync4 } from "node:fs";
-import path13 from "node:path";
+import { spawnSync as spawnSync8 } from "node:child_process";
+import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync4 } from "node:fs";
+import path16 from "node:path";
 var isSafeContextRange = (value) => value.length <= 4096 && (() => {
   try {
     gitRevisionParts(value);
@@ -16002,7 +16833,7 @@ var invalidRange = (cwd) => ({
   cwd
 });
 var runGit = (cwd, args) => {
-  const result = spawnSync7("git", args, { cwd, encoding: "utf8" });
+  const result = spawnSync8("git", args, { cwd, encoding: "utf8" });
   return {
     stdout: (result.stdout ?? "").trimEnd(),
     stderr: (result.stderr ?? "").trimEnd(),
@@ -16013,11 +16844,11 @@ var repoRoot = (cwd) => {
   const r = runGit(cwd, ["rev-parse", "--show-toplevel"]);
   return r.exitCode === 0 && r.stdout ? r.stdout : cwd;
 };
-var currentBranch = (cwd) => {
+var currentBranch2 = (cwd) => {
   const r = runGit(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
   return r.exitCode === 0 && r.stdout ? r.stdout : "unknown";
 };
-var defaultBase = (cwd) => {
+var defaultBase2 = (cwd) => {
   for (const ref of [
     "origin/main",
     "main",
@@ -16031,11 +16862,11 @@ var defaultBase = (cwd) => {
   }
   return "HEAD~1";
 };
-var rangeArgOrDefault = (arg, cwd) => arg ? arg : `${defaultBase(cwd)}...HEAD`;
+var rangeArgOrDefault = (arg, cwd) => arg ? arg : `${defaultBase2(cwd)}...HEAD`;
 var isProtectedBranch = (branch) => ["main", "master", "develop", "prod", "production"].includes(branch);
 var isPrBranch = (branch) => branch.startsWith("feature/") || branch.startsWith("bugfix/");
 function resolvePrBranchContext(cwd) {
-  const branch = currentBranch(cwd);
+  const branch = currentBranch2(cwd);
   if (isProtectedBranch(branch)) {
     return {
       ok: false,
@@ -16109,7 +16940,7 @@ var findPrTemplate = (cwd) => {
   ]) {
     const parts = rel.split("/");
     const base = parts[parts.length - 1];
-    const dir = parts.length > 1 ? path13.join(cwd, ...parts.slice(0, -1)) : cwd;
+    const dir = parts.length > 1 ? path16.join(cwd, ...parts.slice(0, -1)) : cwd;
     const actual = probeCaseInsensitive(dir, base);
     if (actual)
       return [...parts.slice(0, -1), actual].join("/");
@@ -16140,8 +16971,8 @@ var diffStatForRange = (cwd, range) => {
   return runGit(cwd, ["diff", "--stat", "--"]).stdout;
 };
 var packageScripts = (cwd, keys) => {
-  const pkgPath = path13.join(cwd, "package.json");
-  if (!existsSync5(pkgPath))
+  const pkgPath = path16.join(cwd, "package.json");
+  if (!existsSync6(pkgPath))
     return [];
   try {
     const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
@@ -16166,9 +16997,9 @@ var documentationFiles = (cwd) => {
       if (entry.isDirectory()) {
         if (excluded.has(entry.name))
           continue;
-        walk(path13.join(dir, entry.name), depth + 1);
+        walk(path16.join(dir, entry.name), depth + 1);
       } else if (entry.isFile() && (entry.name === "README.md" || entry.name.endsWith(".md"))) {
-        matches.push("./" + path13.relative(cwd, path13.join(dir, entry.name)).replaceAll("\\", "/"));
+        matches.push("./" + path16.relative(cwd, path16.join(dir, entry.name)).replaceAll("\\", "/"));
       }
     }
   };
@@ -16176,7 +17007,7 @@ var documentationFiles = (cwd) => {
   return matches.toSorted().slice(0, 200);
 };
 var readTrimmed2 = (file, maxLines) => {
-  if (!existsSync5(file))
+  if (!existsSync6(file))
     return "";
   const lines = readFileSync5(file, "utf8").split(`
 `);
@@ -16184,7 +17015,7 @@ var readTrimmed2 = (file, maxLines) => {
 `);
 };
 function prReadyContext(root, range) {
-  const cwd = path13.resolve(repoRoot(root));
+  const cwd = path16.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   let stdout = "";
@@ -16200,7 +17031,7 @@ function prReadyContext(root, range) {
   stdout += printSection("Repository");
   stdout += `root: ${cwd}
 `;
-  stdout += `branch: ${currentBranch(cwd)}
+  stdout += `branch: ${currentBranch2(cwd)}
 `;
   stdout += `range: ${range}
 `;
@@ -16242,7 +17073,7 @@ ${status.stderr}` : "");
     stdout += `template_path: ${template}
 
 `;
-    stdout += readTrimmed2(path13.join(cwd, template), 220);
+    stdout += readTrimmed2(path16.join(cwd, template), 220);
   } else {
     stdout += `template_path: none
 
@@ -16252,7 +17083,7 @@ ${status.stderr}` : "");
   stdout += `
 `;
   stdout += printSection("Recent Validation Signals");
-  if (existsSync5(path13.join(cwd, "package.json"))) {
+  if (existsSync6(path16.join(cwd, "package.json"))) {
     stdout += `package.json detected. Common scripts:
 `;
     const found = packageScripts(cwd, ["lint", "format:check", "test", "build"]);
@@ -16261,7 +17092,7 @@ ${status.stderr}` : "");
 `) + `
 `;
   }
-  if (existsSync5(path13.join(cwd, "Cargo.toml")) || existsSync5(path13.join(cwd, "src-tauri/Cargo.toml"))) {
+  if (existsSync6(path16.join(cwd, "Cargo.toml")) || existsSync6(path16.join(cwd, "src-tauri/Cargo.toml"))) {
     stdout += `Rust project detected.
 `;
   }
@@ -16294,7 +17125,7 @@ var CHANGELOG_RULES = `- Use an [Unreleased] section.
 - Apply with the host-native editor, preserving the repository changelog conventions.
 - If Unreleased already has duplicate category headings, normalize_only first.`;
 function changelogContext(root, range) {
-  const cwd = path13.resolve(repoRoot(root));
+  const cwd = path16.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   const resolvedRange = rangeArgOrDefault(range, cwd);
@@ -16304,7 +17135,7 @@ function changelogContext(root, range) {
   stdout += printSection("Repository");
   stdout += `root: ${cwd}
 `;
-  stdout += `branch: ${currentBranch(cwd)}
+  stdout += `branch: ${currentBranch2(cwd)}
 `;
   stdout += `range: ${resolvedRange}
 `;
@@ -16312,8 +17143,8 @@ function changelogContext(root, range) {
   stdout += CHANGELOG_RULES + `
 `;
   stdout += printSection("Existing CHANGELOG.md");
-  const changelogPath = path13.join(cwd, "CHANGELOG.md");
-  if (existsSync5(changelogPath)) {
+  const changelogPath = path16.join(cwd, "CHANGELOG.md");
+  if (existsSync6(changelogPath)) {
     stdout += readTrimmed2(changelogPath, 260) + `
 `;
   } else {
@@ -16332,7 +17163,7 @@ function changelogContext(root, range) {
   return { stdout, stderr: "", exitCode: 0, cwd };
 }
 function docsRefreshContext(root, range) {
-  const cwd = path13.resolve(repoRoot(root));
+  const cwd = path16.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   const resolvedRange = rangeArgOrDefault(range, cwd);
@@ -16342,7 +17173,7 @@ function docsRefreshContext(root, range) {
   stdout += printSection("Repository");
   stdout += `root: ${cwd}
 `;
-  stdout += `branch: ${currentBranch(cwd)}
+  stdout += `branch: ${currentBranch2(cwd)}
 `;
   stdout += `range: ${resolvedRange}
 `;
@@ -16354,8 +17185,8 @@ function docsRefreshContext(root, range) {
 `) + `
 `;
   stdout += printSection("README Preview");
-  const readme = path13.join(cwd, "README.md");
-  if (existsSync5(readme)) {
+  const readme = path16.join(cwd, "README.md");
+  if (existsSync6(readme)) {
     stdout += readTrimmed2(readme, 220) + `
 `;
   } else {
@@ -16363,8 +17194,8 @@ function docsRefreshContext(root, range) {
 `;
   }
   stdout += printSection("Package Scripts");
-  const pkgPath = path13.join(cwd, "package.json");
-  if (existsSync5(pkgPath)) {
+  const pkgPath = path16.join(cwd, "package.json");
+  if (existsSync6(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
       stdout += JSON.stringify({ name: pkg.name, version: pkg.version, scripts: pkg.scripts }, null, 2) + `
@@ -16377,7 +17208,7 @@ function docsRefreshContext(root, range) {
   return { stdout, stderr: "", exitCode: 0, cwd };
 }
 function releaseNotesContext(root, rangeOrTag) {
-  const cwd = path13.resolve(repoRoot(root));
+  const cwd = path16.resolve(repoRoot(root));
   if (!rangeOrTag) {
     return { stdout: "", stderr: `ERROR: release tag or range required
 `, exitCode: 1, cwd };
@@ -16391,7 +17222,7 @@ function releaseNotesContext(root, rangeOrTag) {
   stdout += printSection("Repository");
   stdout += `root: ${cwd}
 `;
-  stdout += `branch: ${currentBranch(cwd)}
+  stdout += `branch: ${currentBranch2(cwd)}
 `;
   stdout += `requested: ${rangeOrTag}
 `;
@@ -16415,7 +17246,7 @@ function releaseNotesContext(root, rangeOrTag) {
 `;
   stdout += printSection("Existing Release Files");
   for (const rel of ["CHANGELOG.md", "RELEASE_NOTES.md", ".github/releases.md"]) {
-    if (existsSync5(path13.join(cwd, rel)))
+    if (existsSync6(path16.join(cwd, rel)))
       stdout += rel + `
 `;
   }
@@ -16443,12 +17274,12 @@ function releaseNotesContext(root, rangeOrTag) {
 }
 
 // packages/workit-core/src/core/tracker-issues.ts
-import { spawnSync as spawnSync9 } from "node:child_process";
+import { spawnSync as spawnSync10 } from "node:child_process";
 
 // packages/workit-core/src/core/pr-create.ts
-import fs12 from "node:fs";
-import path14 from "node:path";
-import { spawnSync as spawnSync8 } from "node:child_process";
+import fs13 from "node:fs";
+import path17 from "node:path";
+import { spawnSync as spawnSync9 } from "node:child_process";
 // packages/workit-core/src/forge/pr-body.ts
 function parseGhIssue(value) {
   const m = /issues\/(\d+)/.exec(value);
@@ -16458,13 +17289,13 @@ function parseGhIssue(value) {
 // packages/workit-core/src/core/pr-create.ts
 function whichOnPath(tool) {
   const names = process.platform === "win32" ? [tool, `${tool}.exe`, `${tool}.cmd`] : [tool];
-  for (const dir of (process.env.PATH ?? "").split(path14.delimiter)) {
+  for (const dir of (process.env.PATH ?? "").split(path17.delimiter)) {
     if (!dir)
       continue;
     for (const name of names) {
-      const candidate = path14.join(dir, name);
+      const candidate = path17.join(dir, name);
       try {
-        fs12.accessSync(candidate, fs12.constants.X_OK);
+        fs13.accessSync(candidate, fs13.constants.X_OK);
         return candidate;
       } catch {}
     }
@@ -16473,7 +17304,7 @@ function whichOnPath(tool) {
 }
 var hostingCliAvailable = (provider) => whichOnPath(provider === "gitlab" ? "glab" : "gh") !== null;
 var pushRemote = (cwd) => {
-  const result = spawnSync8("git", ["remote", "get-url", "--push", "--all", "origin"], {
+  const result = spawnSync9("git", ["remote", "get-url", "--push", "--all", "origin"], {
     cwd,
     encoding: "utf8"
   });
@@ -16504,7 +17335,7 @@ var defaultCli = (bin, available) => {
   if (!available)
     return null;
   return (args, root) => {
-    const out = spawnSync9(bin, args, {
+    const out = spawnSync10(bin, args, {
       cwd: root,
       encoding: "utf8",
       env: { ...process.env, PATH: process.env.PATH ?? "" }
@@ -16582,8 +17413,8 @@ var fetchGitLabIssueBody = async (ref, root, deps = {}) => {
 };
 
 // packages/workit-core/src/core/youtrack.ts
-import fs13 from "node:fs";
-import path15 from "node:path";
+import fs14 from "node:fs";
+import path18 from "node:path";
 
 // packages/workit-core/src/core/templates.ts
 var repoRoot2 = assetRoot();
@@ -16596,22 +17427,22 @@ var resolveWorkspaceRoot = (explicit) => explicit || process.cwd();
 // packages/workit-core/src/core/youtrack.ts
 var ISSUE_RE = /^[A-Z]+-\d+$/;
 var TOKEN_PLACEHOLDER = "YOUR_TOKEN_HERE";
-var youTrackConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path15.join(configDir(), "youtrack.json");
-var youTrackReadOnlyConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path15.join(resolveConfigDir(), "youtrack.json");
+var youTrackConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path18.join(configDir(), "youtrack.json");
+var youTrackReadOnlyConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path18.join(resolveConfigDir(), "youtrack.json");
 var youTrackTokenModeOk = (p) => {
   if (process.platform === "win32")
     return true;
-  const mode = fs13.statSync(p).mode & 511;
+  const mode = fs14.statSync(p).mode & 511;
   return mode === 384;
 };
 function readYouTrackConfig(required) {
   const cfgPath = youTrackConfigPath();
-  if (!fs13.existsSync(cfgPath)) {
+  if (!fs14.existsSync(cfgPath)) {
     return required ? { error: "ERROR: missing youtrack.json", path: cfgPath } : { config: {}, path: cfgPath };
   }
   let parsed;
   try {
-    parsed = JSON.parse(fs13.readFileSync(cfgPath, "utf8"));
+    parsed = JSON.parse(fs14.readFileSync(cfgPath, "utf8"));
   } catch {
     return { error: `${cfgPath} is not valid JSON`, path: cfgPath };
   }
@@ -16622,11 +17453,11 @@ function readYouTrackConfig(required) {
 }
 var readYouTrackContextConfig = () => {
   const cfgPath = youTrackReadOnlyConfigPath();
-  if (!fs13.existsSync(cfgPath))
+  if (!fs14.existsSync(cfgPath))
     return { data: {} };
   let parsed;
   try {
-    parsed = JSON.parse(fs13.readFileSync(cfgPath, "utf8"));
+    parsed = JSON.parse(fs14.readFileSync(cfgPath, "utf8"));
   } catch {
     return { error: "YouTrack configuration is unavailable" };
   }
@@ -16665,12 +17496,12 @@ var youTrackToken = () => {
   if ("error" in loaded)
     return loaded;
   const tokenFile = String(loaded.config.tokenFile ?? "");
-  const tokenPath = tokenFile ? path15.isAbsolute(tokenFile) ? path15.resolve(tokenFile) : path15.resolve(process.cwd(), tokenFile) : "";
-  if (!tokenPath || !fs13.existsSync(tokenPath))
+  const tokenPath = tokenFile ? path18.isAbsolute(tokenFile) ? path18.resolve(tokenFile) : path18.resolve(process.cwd(), tokenFile) : "";
+  if (!tokenPath || !fs14.existsSync(tokenPath))
     return { error: "missing youtrack.token" };
   if (!youTrackTokenModeOk(tokenPath))
     return { error: "youtrack.token mode must be 0600" };
-  const token = fs13.readFileSync(tokenPath, "utf8").trim();
+  const token = fs14.readFileSync(tokenPath, "utf8").trim();
   if (!token)
     return { error: "empty token file" };
   if (token === TOKEN_PLACEHOLDER || token.startsWith(TOKEN_PLACEHOLDER)) {
@@ -16716,7 +17547,7 @@ function youTrackTokenCreateUrl() {
   const desc = String(defaults.description ?? "OpenCode workit — /wk-issue-update and /wk-meetings");
   const scopes = Array.isArray(defaults.scopes) ? defaults.scopes : ["YouTrack"];
   const base = String(config.baseUrl ?? "").replace(/\/+$/, "");
-  const tokenFile = String(config.tokenFile ?? path15.join(path15.dirname(loaded.path), "youtrack.token"));
+  const tokenFile = String(config.tokenFile ?? path18.join(path18.dirname(loaded.path), "youtrack.token"));
   const tab = String(defaults.profileTab ?? "account-security");
   const createUrl = base ? `${base}/users/me?${new URLSearchParams({ tab })}` : null;
   const docsUrl = "https://www.jetbrains.com/help/youtrack/cloud/manage-permanent-token.html";
@@ -16725,7 +17556,7 @@ function youTrackTokenCreateUrl() {
       tokenName: name,
       tokenDescription: desc,
       scopes,
-      tokenFile: path15.resolve(tokenFile),
+      tokenFile: path18.resolve(tokenFile),
       createUrl,
       docsUrl,
       prefillSupported: false,
@@ -16771,9 +17602,9 @@ function resolveYouTrackFromPaths(spec_path, plan_path, workspace_root) {
     } catch {
       continue;
     }
-    if (!fs13.existsSync(full))
+    if (!fs14.existsSync(full))
       continue;
-    const text = fs13.readFileSync(full, "utf8");
+    const text = fs14.readFileSync(full, "utf8");
     const m = text.match(/^\*\*YouTrack:\*\*\s*`?([A-Z]+-\d+)`?/m);
     if (m)
       return m[1];
@@ -17065,22 +17896,22 @@ function resolveGitRevision(root, value) {
 }
 function resolveInside(root, candidate) {
   const base = realpathSync5(root);
-  const target = path16.resolve(base, candidate);
-  if (target !== base && !target.startsWith(base + path16.sep)) {
+  const target = path19.resolve(base, candidate);
+  if (target !== base && !target.startsWith(base + path19.sep)) {
     throw new Error("path must stay inside repository root");
   }
   let ancestor = target;
-  while (!existsSync6(ancestor))
-    ancestor = path16.dirname(ancestor);
+  while (!existsSync7(ancestor))
+    ancestor = path19.dirname(ancestor);
   const canonicalAncestor = realpathSync5(ancestor);
-  if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path16.sep)) {
+  if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path19.sep)) {
     throw new Error("path must stay inside repository root");
   }
   return target;
 }
 function run2(root, executable, args, env = {}) {
   const cwd = realpathSync5(root);
-  const result = spawnSync10(executable, args, {
+  const result = spawnSync11(executable, args, {
     cwd,
     encoding: "utf8",
     env: { ...process.env, ...env }
@@ -17117,7 +17948,7 @@ var capabilitiesFor = (descriptor, observed = {}) => descriptor.capabilities.map
   };
 });
 // packages/workit-core/src/hooks/context.ts
-import path17 from "node:path";
+import path20 from "node:path";
 var MIGRATION_PENDING_NOTE = "workit migration pending — run `workit task status`";
 var migrationPending = (result) => !result.ok && result.code === "needs_input" && (result.error ?? "").startsWith(MIGRATION_PENDING);
 var boundTo = (entry, session) => entry.sessions.some((item) => item.host === session.host && item.handle === session.handle);
@@ -17196,7 +18027,7 @@ function entryCompactContext(store, entry, session, context) {
     return null;
   const freshness = { mode: "signal", current: () => recentSignal(store.root) };
   const observed = task.data.evidence.some(isObservedCheck);
-  const files = task.data.decisions.flatMap((decision) => decision.data.binding.contentRefs.flatMap((ref) => ref.kind === "file" ? [path17.resolve(store.root, ref.path)] : []));
+  const files = task.data.decisions.flatMap((decision) => decision.data.binding.contentRefs.flatMap((ref) => ref.kind === "file" ? [path20.resolve(store.root, ref.path)] : []));
   const observedFiles = filesKey(files);
   const compact = new WorkitCore(store, context).compactContext(entry.id, freshness);
   if (!compact.ok)
@@ -17218,12 +18049,291 @@ var shellPolicy = (cwd, command) => {
   const policy = shellBranchPolicyViolation(cwd, command);
   return policy && !policy.ok ? { kind: "deny", reason: `branch_policy_denied: ${policy.error}`, unblock: null } : { kind: "none" };
 };
+// packages/workit-core/src/hooks/write-gate.ts
+import { realpathSync as realpathSync6 } from "node:fs";
+import path21 from "node:path";
+var NONE2 = { kind: "none" };
+var CASE_INSENSITIVE = process.platform === "darwin" || process.platform === "win32";
+var canonical2 = (file) => {
+  let rest = "";
+  for (let dir = path21.resolve(file);; dir = path21.dirname(dir)) {
+    try {
+      return path21.join(realpathSync6(dir), rest);
+    } catch {
+      if (path21.dirname(dir) === dir)
+        return path21.resolve(file);
+      rest = rest ? path21.join(path21.basename(dir), rest) : path21.basename(dir);
+    }
+  }
+};
+var exempt = (cwd, root, file, plans) => {
+  const fold = (value) => CASE_INSENSITIVE ? value.toLowerCase() : value;
+  const relative = path21.relative(fold(canonical2(root)), fold(canonical2(path21.resolve(cwd, file))));
+  if (relative.startsWith("..") || path21.isAbsolute(relative))
+    return true;
+  const posix = relative.split(path21.sep).join("/");
+  const segments = posix.split("/");
+  return /\.mdx?$/i.test(posix) || segments[0] === "docs" || segments.includes("plans") || [...plans].some((plan) => fold(plan) === posix);
+};
+var segmentsOf = (command) => {
+  const segments = [];
+  let current = { words: [], redirects: [] };
+  let word = "";
+  let inWord = false;
+  let pending = null;
+  const heredocs = [];
+  const flushWord = () => {
+    if (!inWord)
+      return;
+    if (pending === "redirect") {
+      if (!word.startsWith("&"))
+        current.redirects.push(word);
+    } else if (pending === "heredoc")
+      heredocs.push(word.replace(/^-/, ""));
+    else if (pending !== "input")
+      current.words.push(word);
+    pending = null;
+    word = "";
+    inWord = false;
+  };
+  const flushSegment = () => {
+    flushWord();
+    if (current.words.length || current.redirects.length)
+      segments.push(current);
+    current = { words: [], redirects: [] };
+  };
+  for (let index = 0;index < command.length; index++) {
+    const char = command[index];
+    if (char === "'" || char === '"') {
+      const end = command.indexOf(char, index + 1);
+      word += command.slice(index + 1, end < 0 ? undefined : end);
+      inWord = true;
+      index = end < 0 ? command.length : end;
+    } else if (char === "\\" && index + 1 < command.length) {
+      word += command[++index];
+      inWord = true;
+    } else if (char === `
+`) {
+      flushSegment();
+      while (heredocs.length) {
+        const delimiter = heredocs.shift();
+        const lines = command.slice(index + 1).split(`
+`);
+        const at = lines.findIndex((line) => line.trim() === delimiter);
+        const skipped = (at < 0 ? lines : lines.slice(0, at + 1)).join(`
+`).length + 1;
+        index += skipped;
+      }
+    } else if (/\s/.test(char))
+      flushWord();
+    else if (";&|()".includes(char)) {
+      if (char === "&" && command[index + 1] === ">")
+        continue;
+      flushSegment();
+    } else if (char === ">") {
+      if (inWord && /^\d$/.test(word)) {
+        word = "";
+        inWord = false;
+      } else
+        flushWord();
+      if (command[index + 1] === ">")
+        index++;
+      if (command[index + 1] === "&") {
+        index++;
+        word = "&";
+        inWord = true;
+      }
+      pending = "redirect";
+    } else if (char === "<") {
+      flushWord();
+      if (command[index + 1] === "<") {
+        index++;
+        if (command[index + 1] === "<")
+          index++;
+        pending = "heredoc";
+      } else
+        pending = "input";
+    } else {
+      word += char;
+      inWord = true;
+    }
+  }
+  flushSegment();
+  return segments;
+};
+var PREFIXES = new Set(["sudo", "command", "env", "nohup", "time", "exec", "xargs"]);
+var operands = (words) => words.filter((item) => !item.startsWith("-"));
+var editsOf = (input) => {
+  let words = input;
+  while (words.length && (PREFIXES.has(words[0]) || /^\w+=/.test(words[0])))
+    words = words.slice(1);
+  const [verb, ...args] = words;
+  const name = (verb?.split(/[\\/]/).at(-1) ?? "").toLowerCase();
+  if (!name || name === "workit" || name === "npx" && args.some((item) => /workit/.test(item)))
+    return [];
+  switch (name) {
+    case "touch":
+    case "mkdir":
+    case "rm":
+    case "rmdir":
+    case "tee":
+    case "mv":
+    case "truncate":
+      return operands(args);
+    case "cp":
+    case "ln":
+    case "install": {
+      const target = args.indexOf("-t");
+      if (target >= 0)
+        return args[target + 1] ? [args[target + 1]] : null;
+      const last = operands(args).at(-1);
+      return last ? [last] : null;
+    }
+    case "dd":
+      return args.filter((item) => item.startsWith("of=")).map((item) => item.slice(3));
+    case "sed":
+    case "perl": {
+      if (!args.some((item) => /^-[a-zA-Z]*i|^--in-place/.test(item)))
+        return [];
+      const scripted = args.some((item) => item === "-e" || item === "-f");
+      const files = [];
+      for (let index = 0;index < args.length; index++) {
+        if (args[index] === "-e" || args[index] === "-f")
+          index++;
+        else if (!args[index].startsWith("-"))
+          files.push(args[index]);
+      }
+      return scripted ? files : files.slice(1);
+    }
+    case "patch":
+      return null;
+    case "set-content":
+    case "add-content":
+    case "out-file":
+    case "new-item":
+    case "ni":
+    case "remove-item":
+    case "del":
+    case "copy-item":
+    case "move-item": {
+      const flag = args.findIndex((item) => /^-(?:path|filepath|literalpath|destination)$/i.test(item));
+      if (flag >= 0)
+        return args[flag + 1] ? [args[flag + 1]] : null;
+      const files = operands(args);
+      if (name === "move-item")
+        return files.length ? files : null;
+      const file = name === "copy-item" ? files.at(-1) : files[0];
+      return file ? [file] : null;
+    }
+    case "git": {
+      const sub = operands(args)[0];
+      if (sub === "apply")
+        return null;
+      if (sub === "restore" || sub === "mv" || sub === "rm")
+        return operands(args).slice(1);
+      if (sub === "checkout" && args.includes("--"))
+        return args.slice(args.indexOf("--") + 1);
+      return [];
+    }
+    default:
+      return [];
+  }
+};
+var shellWrites = (command) => {
+  const targets = [];
+  let unknown = false;
+  for (const segment of segmentsOf(command)) {
+    targets.push(...segment.redirects.filter((item) => !/^\/dev\/(?:null|stdout|stderr|tty)$/.test(item)));
+    const edits = editsOf(segment.words);
+    if (edits === null)
+      unknown = true;
+    else
+      targets.push(...edits);
+  }
+  if (!unknown && targets.length === 0)
+    return { writes: false, targets: null };
+  return { writes: true, targets: unknown ? null : targets };
+};
+var cache2 = new Map;
+var planKeyOf = (root, plans) => [...plans].map((file) => fileSignature(path21.resolve(root, file)) ?? "-").join("\x00");
+var gateFor = (cwd) => {
+  const store = new TaskStore(cwd);
+  const listed = store.listTaskIndex();
+  if (!listed.ok)
+    return null;
+  const key = store.currentKey();
+  if (!key.ok)
+    return null;
+  const entry = listed.data.filter((item) => item.key === key.data.key && item.status !== "closed").toSorted((left, right) => right.updatedAt.localeCompare(left.updatedAt))[0];
+  if (!entry)
+    return { blockers: [], root: store.root, plans: new Set };
+  const ledger = ledgerPath(store.root);
+  const cacheKey = `${entry.id}\x00${entry.revision}\x00${ledger.ok && fileSignature(ledger.value) || "-"}`;
+  const hit = cache2.get(store.root);
+  if (hit && hit.key === cacheKey && hit.planKey === planKeyOf(store.root, hit.plans))
+    return hit;
+  const task = store.readTask(entry.id);
+  if (!task.ok)
+    return null;
+  const workspace = store.readWorkspace();
+  const plans = new Set((latestJudgment(task.data)?.refs ?? []).flatMap((ref) => ref.kind === "file" ? [ref.path] : []));
+  const blockers = writeBlockers(task.data, store.root).filter((blocker) => {
+    const requirement = task.data.policy?.requirements.find((item) => item.ruleId === blocker.ruleId && item.before === "write");
+    return !(requirement?.acceptanceAllowed && workspace.ok && workspace.data && applicableDecision(task.data, workspace.data, requirement, store.root).length > 0);
+  });
+  const gate = {
+    blockers,
+    root: store.root,
+    plans,
+    key: cacheKey,
+    planKey: planKeyOf(store.root, plans)
+  };
+  cache2.set(store.root, gate);
+  if (cache2.size > 32)
+    cache2.delete(cache2.keys().next().value);
+  return gate;
+};
+function writeGate(cwd, paths) {
+  try {
+    const gate = gateFor(cwd);
+    if (!gate || gate.blockers.length === 0)
+      return NONE2;
+    if (paths && paths.every((file) => exempt(cwd, gate.root, file, gate.plans)))
+      return NONE2;
+    const reasons = gate.blockers.map((item) => `${item.ruleId}: ${item.reason}`).join("; ");
+    return {
+      kind: "deny",
+      reason: `workit before-write gate: ${reasons}. Markdown, docs/, plans/ and files outside the checkout stay writable.`,
+      unblock: gate.blockers[0].reason
+    };
+  } catch {
+    return NONE2;
+  }
+}
+// packages/workit-core/src/hooks/hosts/fields.ts
+var SHELLS = new Set(["sh", "bash", "zsh", "dash", "pwsh", "powershell", "cmd"]);
+var WRITE_TOOLS = new Set([
+  "write",
+  "edit",
+  "multiedit",
+  "notebookedit",
+  "applypatch",
+  "patch",
+  "delete",
+  "remove",
+  "rename",
+  "mkdir",
+  "mv",
+  "cp",
+  "touch",
+  "strreplace",
+  "searchreplace",
+  "editfile",
+  "writefile"
+]);
 // packages/workit-core/src/hooks/handle.ts
 var offered = new Set;
 var CLAUDE_JUDGES = new Set(["workit:verifier", "workit:reviewer"]);
-// packages/workit-core/src/hooks/hosts/fields.ts
-var SHELLS = new Set(["sh", "bash", "zsh", "dash", "pwsh", "powershell", "cmd"]);
-
 // packages/workit-core/src/hooks/hosts/claude-code.ts
 var SOURCES = new Set(["startup", "resume", "clear", "compact", "fork"]);
 var SHELL_TOOLS = new Set(["Bash", "PowerShell"]);
@@ -17250,6 +18360,7 @@ var OPENCODE_DESCRIPTOR = {
     "context.turn": { support: "native", native: 'session.hook("context")' },
     "shell.pre": { support: "native", native: 'permission.hook("evaluate")' },
     "tool.pre": { support: "native", native: 'tool.hook("execute.before")' },
+    "write.pre": { support: "native", native: 'permission.hook("evaluate")' },
     "shell.post": { support: "native", native: 'tool.hook("execute.after")' },
     "subagent.start": { support: "native", native: 'tool.hook("execute.before") subagent' },
     "subagent.stop": { support: "native", native: 'tool.hook("execute.after") subagent' },
@@ -17304,11 +18415,11 @@ var OPENCODE_DESCRIPTOR = {
   ]
 };
 // packages/workit-opencode/src/shared/init-apply.ts
-import path22 from "node:path";
+import path26 from "node:path";
 
 // packages/workit-core/src/core/gitignore.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
-import path18 from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
+import path22 from "node:path";
 var GITIGNORE_ENTRIES = [
   "# workit: SDD working state (never commit)",
   "docs/*/sdd/",
@@ -17328,8 +18439,8 @@ var GITIGNORE_ENTRIES = [
 var ensureProjectGitignore = (workspaceRoot, confirmed) => {
   if (!confirmed)
     return { ok: false, error: "confirmed: true required" };
-  const file = path18.join(workspaceRoot, ".gitignore");
-  const existing = existsSync7(file) ? readFileSync6(file, "utf8") : "";
+  const file = path22.join(workspaceRoot, ".gitignore");
+  const existing = existsSync8(file) ? readFileSync6(file, "utf8") : "";
   const existingLines = new Set(existing.split(`
 `).map((l) => l.trim()).filter(Boolean));
   const added = [];
@@ -17344,37 +18455,37 @@ var ensureProjectGitignore = (workspaceRoot, confirmed) => {
     const separator = existing && !existing.endsWith(`
 `) ? `
 ` : "";
-    writeFileSync3(file, existing + separator + (existing ? `
+    writeFileSync4(file, existing + separator + (existing ? `
 ` : "") + append.join(`
 `) + `
 `, "utf8");
-  } else if (!existsSync7(file)) {
-    writeFileSync3(file, "", "utf8");
+  } else if (!existsSync8(file)) {
+    writeFileSync4(file, "", "utf8");
   }
   return { ok: true, path: file, added };
 };
 
 // packages/workit-core/src/core/hygiene.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
-import path19 from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
+import path23 from "node:path";
 var repoRoot3 = assetRoot();
-var templatesDir = () => path19.join(repoRoot3, "templates", "hygiene");
+var templatesDir = () => path23.join(repoRoot3, "templates", "hygiene");
 var packageJson = (root) => {
-  if (!existsSync8(path19.join(root, "package.json")))
+  if (!existsSync9(path23.join(root, "package.json")))
     return null;
   try {
-    return JSON.parse(readFileSync7(path19.join(root, "package.json"), "utf8"));
+    return JSON.parse(readFileSync7(path23.join(root, "package.json"), "utf8"));
   } catch {
     return null;
   }
 };
 var isOpenSource = (root) => {
-  if (existsSync8(path19.join(root, "LICENSE")))
+  if (existsSync9(path23.join(root, "LICENSE")))
     return true;
   const pkg = packageJson(root);
   if (pkg && !pkg.private)
     return true;
-  return path19.basename(root) === "workflow-toolkit";
+  return path23.basename(root) === "workflow-toolkit";
 };
 var licenseHolder = (root) => {
   const pkg = packageJson(root);
@@ -17397,13 +18508,13 @@ var planHygieneFiles = (root, opts = {}) => {
     files.push("LICENSE", "CONTRIBUTING.md");
   const planned = [];
   for (const file of files) {
-    if (existsSync8(path19.join(root, file)))
+    if (existsSync9(path23.join(root, file)))
       continue;
-    const tpl = path19.join(templatesDir(), file);
-    if (!existsSync8(tpl))
+    const tpl = path23.join(templatesDir(), file);
+    if (!existsSync9(tpl))
       continue;
-    const content = readFileSync7(tpl, "utf8").replace(/<PROJECT>/g, path19.basename(root)).replace(/<YEAR>/g, String(new Date().getFullYear())).replace(/<HOLDER>\s*/g, licenseHolder(root));
-    planned.push({ path: path19.join(root, file), content });
+    const content = readFileSync7(tpl, "utf8").replace(/<PROJECT>/g, path23.basename(root)).replace(/<YEAR>/g, String(new Date().getFullYear())).replace(/<HOLDER>\s*/g, licenseHolder(root));
+    planned.push({ path: path23.join(root, file), content });
   }
   return planned;
 };
@@ -17412,48 +18523,25 @@ var ensureHygieneFiles = (root, opts) => {
     return { ok: false, error: "confirmed: true required" };
   const created = [];
   for (const planned of planHygieneFiles(root, opts)) {
-    writeFileSync4(planned.path, planned.content, "utf8");
-    created.push(path19.basename(planned.path));
+    writeFileSync5(planned.path, planned.content, "utf8");
+    created.push(path23.basename(planned.path));
   }
   return { ok: true, created };
 };
 
 // packages/workit-core/src/core/init.ts
-import fs14 from "node:fs";
-import path21 from "node:path";
-import { spawnSync as spawnSync12 } from "node:child_process";
-
-// packages/workit-core/src/core/safe-write.ts
-import {
-  closeSync as closeSync2,
-  fchmodSync,
-  fsyncSync,
-  lstatSync as lstatSync3,
-  mkdirSync as mkdirSync3,
-  openSync as openSync2,
-  renameSync as renameSync2,
-  unlinkSync,
-  writeFileSync as writeFileSync5
-} from "node:fs";
-function writeFileExclusive(file, content, mode) {
-  try {
-    writeFileSync5(file, content, { encoding: "utf8", flag: "wx", mode });
-    return "created";
-  } catch (err) {
-    if (err.code === "EEXIST")
-      return "preserved";
-    throw err;
-  }
-}
+import fs15 from "node:fs";
+import path25 from "node:path";
+import { spawnSync as spawnSync13 } from "node:child_process";
 
 // packages/workit-core/src/core/workspace-branch-policy.ts
 import { mkdirSync as mkdirSync4, readFileSync as readFileSync8, renameSync as renameSync3, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import path20 from "node:path";
+import path24 from "node:path";
 import { isDeepStrictEqual } from "node:util";
 
 // packages/workit-core/src/core/branch-policy.ts
-import { spawnSync as spawnSync11 } from "node:child_process";
-var PREFIXES = {
+import { spawnSync as spawnSync12 } from "node:child_process";
+var PREFIXES2 = {
   feature: "feature/*",
   bugfix: "bugfix/*",
   release: "release/*",
@@ -17461,7 +18549,7 @@ var PREFIXES = {
 };
 var detectBranchPolicy = (workspaceRoot) => {
   const branchExists = (name) => {
-    const r = spawnSync11("git", ["branch", "--list", name], {
+    const r = spawnSync12("git", ["branch", "--list", name], {
       cwd: workspaceRoot,
       encoding: "utf8"
     });
@@ -17478,7 +18566,7 @@ var detectBranchPolicy = (workspaceRoot) => {
       integration: "merge",
       protected: root ? [root, "develop"] : ["develop"],
       allowed: [...PRESETS.gitflow.allowed],
-      prefixes: PREFIXES
+      prefixes: PREFIXES2
     };
   }
   if (root === "main") {
@@ -17488,7 +18576,7 @@ var detectBranchPolicy = (workspaceRoot) => {
       integration: "pr",
       protected: [root],
       allowed: ["*"],
-      prefixes: PREFIXES
+      prefixes: PREFIXES2
     };
   }
   if (root === "master") {
@@ -17498,7 +18586,7 @@ var detectBranchPolicy = (workspaceRoot) => {
       integration: "pr",
       protected: [root],
       allowed: ["*"],
-      prefixes: PREFIXES
+      prefixes: PREFIXES2
     };
   }
   return {
@@ -17507,7 +18595,7 @@ var detectBranchPolicy = (workspaceRoot) => {
     integration: "merge",
     protected: [],
     allowed: [],
-    prefixes: PREFIXES
+    prefixes: PREFIXES2
   };
 };
 
@@ -17521,7 +18609,7 @@ var readFileSafe = (p) => {
 };
 function applyWorkspaceBranchPolicy(opts) {
   const { workspace_root, env = process.env } = opts;
-  const dir = path20.join(env.WORKFLOW_TOOLKIT_CONFIG ?? configDir());
+  const dir = path24.join(env.WORKFLOW_TOOLKIT_CONFIG ?? configDir());
   const {
     status,
     path: wsPath,
@@ -17533,7 +18621,7 @@ function applyWorkspaceBranchPolicy(opts) {
   if (status === "malformed" || status === "invalid")
     return { ok: false, error: workspacesError ?? `invalid workspaces.json: ${wsPath}` };
   const detection = detectBranchPolicy(workspace_root);
-  const name = String(env.WORKFLOW_BP_NAME ?? path20.basename(workspace_root));
+  const name = String(env.WORKFLOW_BP_NAME ?? path24.basename(workspace_root));
   const integration = env.WORKFLOW_BP_INTEGRATION ?? detection.integration;
   const policy = {
     preset: detection.preset,
@@ -17582,7 +18670,7 @@ function applyWorkspaceBranchPolicy(opts) {
       ok: false,
       error: `workspaces.json changed while applying the branch policy: ${wsPath}`
     };
-  mkdirSync4(path20.dirname(wsPath), { recursive: true });
+  mkdirSync4(path24.dirname(wsPath), { recursive: true });
   const tmp = `${wsPath}.${process.pid}.tmp`;
   try {
     writeFileSync6(tmp, JSON.stringify({ ...document, workspaces: next }, null, 2) + `
@@ -17617,7 +18705,7 @@ function applyWorkspaceBranchPolicy(opts) {
 var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE";
 var readJson = (p) => {
   try {
-    const parsed = JSON.parse(fs14.readFileSync(p, "utf8"));
+    const parsed = JSON.parse(fs15.readFileSync(p, "utf8"));
     return isConfigObject(parsed) ? parsed : null;
   } catch {
     return null;
@@ -17629,7 +18717,7 @@ var resolveInitProvider = (cwd) => {
     return env.toLowerCase();
   const root = cwd ?? process.env.WORKFLOW_WORKSPACE_ROOT ?? process.cwd();
   try {
-    const out = spawnSync12("git", ["remote", "get-url", "origin"], {
+    const out = spawnSync13("git", ["remote", "get-url", "origin"], {
       cwd: root,
       encoding: "utf8"
     });
@@ -17647,7 +18735,7 @@ var youtrackJsonContent = (dir) => {
   const meetingIssue = process.env.WORKFLOW_YT_MEETING_ISSUE;
   return {
     baseUrl: process.env.WORKFLOW_YT_BASE_URL ?? "https://youtrack.example.com",
-    tokenFile: process.env.WORKFLOW_YT_TOKEN_FILE ?? path21.join(dir, "youtrack.token"),
+    tokenFile: process.env.WORKFLOW_YT_TOKEN_FILE ?? path25.join(dir, "youtrack.token"),
     ...meetingIssue ? {
       meetingIssue,
       meetingIssues: { general: { issue: meetingIssue, label: "General meetings" } }
@@ -17677,19 +18765,19 @@ var vcsJsonContent = () => {
 };
 function initApplyData(action, env = process.env) {
   const dir = String(env.WORKFLOW_TOOLKIT_CONFIG ?? configDir());
-  fs14.mkdirSync(dir, { recursive: true });
+  fs15.mkdirSync(dir, { recursive: true });
   switch (action) {
     case "youtrack_json": {
-      const out = path21.join(dir, "youtrack.json");
-      fs14.writeFileSync(out, JSON.stringify(youtrackJsonContent(dir), null, 2) + `
+      const out = path25.join(dir, "youtrack.json");
+      fs15.writeFileSync(out, JSON.stringify(youtrackJsonContent(dir), null, 2) + `
 `, "utf8");
       return { action, ok: true, path: out };
     }
     case "youtrack_token_placeholder": {
-      const p = path21.join(dir, "youtrack.token");
+      const p = path25.join(dir, "youtrack.token");
       const preserved = writeFileExclusive(p, TOKEN_PLACEHOLDER2 + `
 `, 384) === "preserved";
-      const abs = path21.resolve(p);
+      const abs = path25.resolve(p);
       return {
         action,
         ok: true,
@@ -17701,14 +18789,14 @@ function initApplyData(action, env = process.env) {
       };
     }
     case "youtrack_scaffold": {
-      const jsonOut = path21.join(dir, "youtrack.json");
-      const tokenOut = path21.join(dir, "youtrack.token");
-      fs14.writeFileSync(jsonOut, JSON.stringify(youtrackJsonContent(dir), null, 2) + `
+      const jsonOut = path25.join(dir, "youtrack.json");
+      const tokenOut = path25.join(dir, "youtrack.token");
+      fs15.writeFileSync(jsonOut, JSON.stringify(youtrackJsonContent(dir), null, 2) + `
 `, "utf8");
       const preserved = writeFileExclusive(tokenOut, TOKEN_PLACEHOLDER2 + `
 `, 384) === "preserved";
-      const configPath = path21.resolve(jsonOut);
-      const tokenPath = path21.resolve(tokenOut);
+      const configPath = path25.resolve(jsonOut);
+      const tokenPath = path25.resolve(tokenOut);
       const prev = process.env.WORKFLOW_YOUTRACK_CONFIG;
       process.env.WORKFLOW_YOUTRACK_CONFIG = configPath;
       let tokenCreate = {};
@@ -17760,10 +18848,10 @@ function initApplyData(action, env = process.env) {
       }
     }
     case "vcs_scaffold": {
-      const jsonOut = path21.join(dir, "vcs.json");
-      fs14.writeFileSync(jsonOut, JSON.stringify(vcsJsonContent(), null, 2) + `
+      const jsonOut = path25.join(dir, "vcs.json");
+      fs15.writeFileSync(jsonOut, JSON.stringify(vcsJsonContent(), null, 2) + `
 `, "utf8");
-      const configPath = path21.resolve(jsonOut);
+      const configPath = path25.resolve(jsonOut);
       const prev = process.env.WORKFLOW_VCS_CONFIG;
       process.env.WORKFLOW_VCS_CONFIG = configPath;
       try {
@@ -17882,7 +18970,7 @@ var executeInitApply = (args, directory, runtime) => {
       protectedNames: args.branch_policy_protected
     }, current);
     writeConfig(next);
-    return output(ok({ action: "config", path: path22.join(configDir(), "config.json"), ...next }));
+    return output(ok({ action: "config", path: path26.join(configDir(), "config.json"), ...next }));
   }
   const env = Object.fromEntries(Object.entries({
     WORKFLOW_YT_BASE_URL: args.base_url,
@@ -17898,15 +18986,15 @@ var executeInitApply = (args, directory, runtime) => {
 };
 
 // packages/workit-opencode/src/shared/session.ts
-import { realpathSync as realpathSync6 } from "node:fs";
-import path23 from "node:path";
+import { realpathSync as realpathSync7 } from "node:fs";
+import path27 from "node:path";
 var sameWorkspace = (expected, observed) => {
   if (typeof observed !== "string" || !observed)
     return false;
   try {
-    return realpathSync6(expected) === realpathSync6(observed);
+    return realpathSync7(expected) === realpathSync7(observed);
   } catch {
-    return path23.resolve(expected) === path23.resolve(observed);
+    return path27.resolve(expected) === path27.resolve(observed);
   }
 };
 
@@ -17919,8 +19007,8 @@ var objectSchema = (properties, required) => ({
 });
 var familyTools = OPERATION_FAMILIES.map((family) => ({
   name: `workit_${family}`,
-  description: `Workit ${family} operations backed by the shared task contract.`,
-  input: { type: "object", ...boundedOperationJsonSchema(family, OPERATION_SCHEMA_DEPTH) }
+  description: operationDescription(family),
+  input: flatOperationJsonSchema(family)
 }));
 var WORKIT_TOOL_CATALOG = [
   ...familyTools,
@@ -17977,8 +19065,8 @@ var workitFamilyOf = (toolName) => {
 };
 
 // packages/workit-opencode/src/tools/context.ts
-import { realpathSync as realpathSync7 } from "node:fs";
-import path24 from "node:path";
+import { realpathSync as realpathSync8 } from "node:fs";
+import path28 from "node:path";
 var createContextTool = () => ({
   description: "Read Git, pull request, YouTrack, issue, changelog, release, or affected-file context.",
   execute: async (args, context) => {
@@ -17988,7 +19076,7 @@ var createContextTool = () => ({
     let root;
     try {
       const cwd = parsed.data.cwd;
-      root = realpathSync7(cwd ? path24.resolve(context.directory, cwd) : context.directory);
+      root = realpathSync8(cwd ? path28.resolve(context.directory, cwd) : context.directory);
     } catch {
       return JSON.stringify(failure2("invalid_input", "context target directory cannot be resolved"), null, 2);
     }
@@ -18510,24 +19598,37 @@ var injectCompactionContext = (root, sessionID, system) => {
 };
 
 // packages/workit-opencode/src/v2/permissions.ts
+var WRITE_ACTIONS = new Set(["edit", "write", "patch"]);
 var evaluateShellPermission = (root, event) => {
-  if (event.action !== "shell" || event.effect === "deny")
+  if (event.effect === "deny")
     return;
-  for (const resource of event.resources) {
-    if (typeof resource !== "string")
-      continue;
+  const deny = (reason) => {
+    event.effect = "deny";
+    event.message = reason;
+  };
+  const resources = event.resources.filter((resource) => typeof resource === "string");
+  if (WRITE_ACTIONS.has(event.action)) {
+    const decision = writeGate(root, resources);
+    if (decision.kind === "deny")
+      deny(decision.reason);
+    return;
+  }
+  if (event.action !== "shell")
+    return;
+  for (const resource of resources) {
     const decision = shellPolicy(root, resource);
-    if (decision.kind === "deny") {
-      event.effect = "deny";
-      event.message = decision.reason;
-      return;
-    }
+    if (decision.kind === "deny")
+      return deny(decision.reason);
+    const writes = shellWrites(resource);
+    const gated = writes.writes ? writeGate(root, writes.targets) : null;
+    if (gated?.kind === "deny")
+      return deny(gated.reason);
   }
 };
 
 // packages/workit-opencode/src/v2/registry.ts
-import { existsSync as existsSync10, readFileSync as readFileSync9 } from "node:fs";
-import path26 from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync9 } from "node:fs";
+import path30 from "node:path";
 
 // packages/workit-core/src/core/skill-manifests.ts
 var WORKIT_METHOD_SKILLS = [
@@ -18559,34 +19660,34 @@ var WORKIT_SKILL_ALIASES = {
 if (false) {}
 
 // packages/workit-opencode/src/shared/assets.ts
-import { existsSync as existsSync9, realpathSync as realpathSync8 } from "node:fs";
-import path25 from "node:path";
+import { existsSync as existsSync10, realpathSync as realpathSync9 } from "node:fs";
+import path29 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var moduleDir = () => {
   try {
-    return realpathSync8(path25.dirname(fileURLToPath2(import.meta.url)));
+    return realpathSync9(path29.dirname(fileURLToPath2(import.meta.url)));
   } catch {
-    return path25.dirname(fileURLToPath2(import.meta.url));
+    return path29.dirname(fileURLToPath2(import.meta.url));
   }
 };
 var packageRoot2 = () => {
   const dir = moduleDir();
   for (const candidate of [
-    path25.resolve(dir, ".."),
-    path25.resolve(dir, "..", ".."),
-    path25.resolve(dir, "..", "..", "..")
+    path29.resolve(dir, ".."),
+    path29.resolve(dir, "..", ".."),
+    path29.resolve(dir, "..", "..", "..")
   ]) {
-    if (existsSync9(path25.join(candidate, "package.json")))
+    if (existsSync10(path29.join(candidate, "package.json")))
       return candidate;
   }
-  return path25.resolve(dir, "..");
+  return path29.resolve(dir, "..");
 };
 var skillsRoot = () => {
   const root = packageRoot2();
-  const canonical = path25.resolve(root, "..", "workit-core", "skills");
-  if (existsSync9(path25.join(root, "src")) && existsSync9(canonical))
+  const canonical = path29.resolve(root, "..", "workit-core", "skills");
+  if (existsSync10(path29.join(root, "src")) && existsSync10(canonical))
     return canonical;
-  return path25.join(root, "assets", "skills");
+  return path29.join(root, "assets", "skills");
 };
 
 // packages/workit-opencode/src/v2/registry.ts
@@ -18610,15 +19711,15 @@ var parseFrontmatter = (markdown) => {
 };
 var registerSkills = async (ctx) => {
   const skillsDir = skillsRoot();
-  if (!existsSync10(skillsDir))
+  if (!existsSync11(skillsDir))
     return new Set;
   const listed = await ctx.skill.list().catch(() => ({ data: [] }));
-  const own = (skill) => typeof skill.path === "string" && path26.resolve(skill.path).startsWith(skillsDir + path26.sep);
+  const own = (skill) => typeof skill.path === "string" && path30.resolve(skill.path).startsWith(skillsDir + path30.sep);
   const userSkills = new Set((listed?.data ?? []).filter((skill) => !own(skill)).map((skill) => skill.id));
   const packaged = new Map;
   for (const id of WORKIT_METHOD_SKILLS) {
-    const file = path26.join(skillsDir, id, "SKILL.md");
-    if (!userSkills.has(id) && existsSync10(file))
+    const file = path30.join(skillsDir, id, "SKILL.md");
+    if (!userSkills.has(id) && existsSync11(file))
       packaged.set(id, file);
   }
   await ctx.skill.transform((editor) => {
@@ -18664,25 +19765,25 @@ var registerCommands = async (ctx, registeredSkills) => {
 };
 
 // packages/workit-opencode/src/stale-sources.ts
-import { existsSync as existsSync11, readdirSync as readdirSync5 } from "node:fs";
-import path27 from "node:path";
+import { existsSync as existsSync12, readdirSync as readdirSync5 } from "node:fs";
+import path31 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var typescriptFiles = (directory) => {
-  if (!existsSync11(directory))
+  if (!existsSync12(directory))
     return [];
   return readdirSync5(directory, { withFileTypes: true }).flatMap((entry) => {
-    const file = path27.join(directory, entry.name);
+    const file = path31.join(directory, entry.name);
     return entry.isDirectory() ? typescriptFiles(file) : entry.isFile() && file.endsWith(".ts") ? [file] : [];
   });
 };
 var pluginSourceFiles = [
   ...new Set([
     fileURLToPath3(import.meta.url),
-    ...typescriptFiles(path27.join(packageRoot2(), "src")),
-    path27.join(packageRoot2(), "..", "workit-core", "src", "core.ts"),
-    ...typescriptFiles(path27.join(packageRoot2(), "..", "workit-core", "src", "core"))
+    ...typescriptFiles(path31.join(packageRoot2(), "src")),
+    path31.join(packageRoot2(), "..", "workit-core", "src", "core.ts"),
+    ...typescriptFiles(path31.join(packageRoot2(), "..", "workit-core", "src", "core"))
   ])
-].filter((file) => existsSync11(file)).toSorted();
+].filter((file) => existsSync12(file)).toSorted();
 
 // packages/workit-opencode/src/v2/plugin.ts
 var sessionFacts = async (ctx, sessionID) => {
@@ -18736,7 +19837,7 @@ var setup = async (ctx) => {
   });
   const contextTool = createContextTool();
   const runFamily = (family, input, session, store, workerId) => {
-    const parsed = parseOperation(family, input);
+    const parsed = parseAdvertisedOperation(family, input, "opencode");
     if (!parsed.ok)
       return parsed;
     const core = new WorkitCore(store, {