@brainervirus/workit-codex 6.0.1 → 7.0.0

package/dist/launch-mcp.js

@@ -6621,13 +6621,13 @@ var require_dist = __commonJS(function(exports, module) {
 });
 
 // packages/workit-codex/scripts/launch-mcp.ts
-import { existsSync as existsSync8, realpathSync as realpathSync7, statSync as statSync3 } from "node:fs";
-import path18 from "node:path";
+import { existsSync as existsSync9, realpathSync as realpathSync7, statSync as statSync3 } from "node:fs";
+import path21 from "node:path";
 
 // 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";
@@ -12854,12 +12854,6 @@ var numberProcessor = (schema, ctx, _json, params) => {
 var booleanProcessor = (_schema, _ctx, json, _params) => {
   json.type = "boolean";
 };
-var bigintProcessor = (schema, ctx, json, params) => {
-  handleUnrepresentable(schema, ctx, json, params, "BigInt cannot be represented in JSON Schema");
-};
-var symbolProcessor = (schema, ctx, json, params) => {
-  handleUnrepresentable(schema, ctx, json, params, "Symbols cannot be represented in JSON Schema");
-};
 var nullProcessor = (_schema, ctx, json, _params) => {
   if (ctx.target === "openapi-3.0") {
     json.type = "string";
@@ -12869,20 +12863,10 @@ var nullProcessor = (_schema, ctx, json, _params) => {
     json.type = "null";
   }
 };
-var undefinedProcessor = (schema, ctx, json, params) => {
-  handleUnrepresentable(schema, ctx, json, params, "Undefined cannot be represented in JSON Schema");
-};
-var voidProcessor = (schema, ctx, json, params) => {
-  handleUnrepresentable(schema, ctx, json, params, "Void cannot be represented in JSON Schema");
-};
 var neverProcessor = (_schema, _ctx, json, _params) => {
   json.not = {};
 };
-var anyProcessor = (_schema, _ctx, _json, _params) => {};
 var unknownProcessor = (_schema, _ctx, _json, _params) => {};
-var dateProcessor = (schema, ctx, json, params) => {
-  handleUnrepresentable(schema, ctx, json, params, "Date cannot be represented in JSON Schema");
-};
 var enumProcessor = (schema, _ctx, json, _params) => {
   const def = schema._zod.def;
   const values = getEnumValues(def.entries);
@@ -12935,54 +12919,12 @@ var literalProcessor = (schema, ctx, json, params) => {
     json.enum = vals;
   }
 };
-var nanProcessor = (schema, ctx, json, params) => {
-  handleUnrepresentable(schema, ctx, json, params, "NaN cannot be represented in JSON Schema");
-};
-var templateLiteralProcessor = (schema, _ctx, json, _params) => {
-  const _json = json;
-  const pattern = schema._zod.pattern;
-  if (!pattern)
-    throw new Error("Pattern not found in template literal");
-  _json.type = "string";
-  _json.pattern = pattern.source;
-};
-var fileProcessor = (schema, _ctx, json, _params) => {
-  const _json = json;
-  _json.type = "string";
-  _json.format = "binary";
-  _json.contentEncoding = "binary";
-  const { minimum, maximum, mime } = aggregateChecks(schema);
-  if (minimum !== undefined)
-    _json.minLength = minimum;
-  if (maximum !== undefined)
-    _json.maxLength = maximum;
-  if (!mime)
-    return;
-  if (mime.length === 0)
-    _json.not = {};
-  else if (mime.length === 1)
-    _json.contentMediaType = mime[0];
-  else
-    _json.anyOf = mime.map((m) => ({ contentMediaType: m }));
-};
-var successProcessor = (_schema, _ctx, json, _params) => {
-  json.type = "boolean";
-};
 var customProcessor = (schema, ctx, json, params) => {
   handleUnrepresentable(schema, ctx, json, params, "Custom types cannot be represented in JSON Schema");
 };
-var functionProcessor = (schema, ctx, json, params) => {
-  handleUnrepresentable(schema, ctx, json, params, "Function types cannot be represented in JSON Schema");
-};
 var transformProcessor = (schema, ctx, json, params) => {
   handleUnrepresentable(schema, ctx, json, params, "Transforms cannot be represented in JSON Schema");
 };
-var mapProcessor = (schema, ctx, json, params) => {
-  handleUnrepresentable(schema, ctx, json, params, "Map cannot be represented in JSON Schema");
-};
-var setProcessor = (schema, ctx, json, params) => {
-  handleUnrepresentable(schema, ctx, json, params, "Set cannot be represented in JSON Schema");
-};
 var arrayProcessor = (schema, ctx, _json, params) => {
   const json = _json;
   const def = schema._zod.def;
@@ -13076,70 +13018,6 @@ var intersectionProcessor = (schema, ctx, json, params) => {
   json.allOf = allOf;
   ctx.intersections.push(allOf);
 };
-var tupleProcessor = (schema, ctx, _json, params) => {
-  const json = _json;
-  const def = schema._zod.def;
-  json.type = "array";
-  const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
-  const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
-  const prefixItems = def.items.map((x, i) => processSchema(x, ctx, {
-    ...params,
-    path: [...params.path, prefixPath, i]
-  }));
-  const rest = def.rest ? processSchema(def.rest, ctx, {
-    ...params,
-    path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
-  }) : null;
-  let minItems = def.items.length;
-  while (minItems > 0) {
-    const item = def.items[minItems - 1];
-    const optional = ctx.io === "input" ? inputOptin(item) !== undefined : item._zod.optout === "optional";
-    if (!optional)
-      break;
-    minItems--;
-  }
-  const maxItems = def.items.length;
-  const isClosed = !def.rest;
-  if (ctx.target === "draft-2020-12") {
-    json.prefixItems = prefixItems;
-    if (isClosed) {
-      json.items = false;
-    } else if (rest) {
-      json.items = rest;
-    }
-    if (minItems > 0)
-      json.minItems = minItems;
-    if (isClosed)
-      json.maxItems = maxItems;
-  } else if (ctx.target === "openapi-3.0") {
-    json.items = {
-      anyOf: prefixItems
-    };
-    if (rest) {
-      json.items.anyOf.push(rest);
-    }
-    if (minItems > 0)
-      json.minItems = minItems;
-    if (isClosed)
-      json.maxItems = maxItems;
-  } else {
-    json.items = prefixItems;
-    if (isClosed) {
-      json.additionalItems = false;
-    } else if (rest) {
-      json.additionalItems = rest;
-    }
-    if (minItems > 0)
-      json.minItems = minItems;
-    if (isClosed)
-      json.maxItems = maxItems;
-  }
-  const { minimum, maximum } = aggregateChecks(schema);
-  if (typeof minimum === "number")
-    json.minItems = minimum;
-  if (typeof maximum === "number")
-    json.maxItems = maximum;
-};
 function stringifyKeyNames(bySchema, json, visited) {
   if (json.$ref) {
     if (visited.has(json))
@@ -13326,99 +13204,12 @@ var readonlyProcessor = (schema, ctx, json, params) => {
   seen.ref = def.innerType;
   json.readOnly = true;
 };
-var promiseProcessor = (schema, ctx, _json, params) => {
-  const def = schema._zod.def;
-  processSchema(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
-  seen.ref = def.innerType;
-};
 var optionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
-var lazyProcessor = (schema, ctx, _json, params) => {
-  const innerType = schema._zod.innerType;
-  processSchema(innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
-  seen.ref = innerType;
-};
-var allProcessors = {
-  string: stringProcessor,
-  number: numberProcessor,
-  boolean: booleanProcessor,
-  bigint: bigintProcessor,
-  symbol: symbolProcessor,
-  null: nullProcessor,
-  undefined: undefinedProcessor,
-  void: voidProcessor,
-  never: neverProcessor,
-  any: anyProcessor,
-  unknown: unknownProcessor,
-  date: dateProcessor,
-  enum: enumProcessor,
-  literal: literalProcessor,
-  nan: nanProcessor,
-  template_literal: templateLiteralProcessor,
-  file: fileProcessor,
-  success: successProcessor,
-  custom: customProcessor,
-  function: functionProcessor,
-  transform: transformProcessor,
-  map: mapProcessor,
-  set: setProcessor,
-  array: arrayProcessor,
-  object: objectProcessor,
-  union: unionProcessor,
-  intersection: intersectionProcessor,
-  tuple: tupleProcessor,
-  record: recordProcessor,
-  nullable: nullableProcessor,
-  nonoptional: nonoptionalProcessor,
-  default: defaultProcessor,
-  prefault: prefaultProcessor,
-  catch: catchProcessor,
-  pipe: pipeProcessor,
-  readonly: readonlyProcessor,
-  promise: promiseProcessor,
-  optional: optionalProcessor,
-  lazy: lazyProcessor
-};
-function toJSONSchema(input, params) {
-  if ("_idmap" in input) {
-    const registry = input;
-    const ctx = initializeContext({ ...params, processors: allProcessors });
-    const defs = {};
-    for (const entry of registry._idmap.entries()) {
-      const [_, schema] = entry;
-      processSchema(schema, ctx);
-    }
-    const schemas = {};
-    const external = {
-      registry,
-      uri: params?.uri,
-      defs
-    };
-    ctx.external = external;
-    for (const entry of registry._idmap.entries()) {
-      const [key, schema] = entry;
-      extractDefs(ctx, schema);
-      assignProp(schemas, key, finalize(ctx, schema));
-    }
-    if (Object.keys(defs).length > 0) {
-      const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
-      schemas.__shared = {
-        [defsSegment]: defs
-      };
-    }
-    return { schemas };
-  }
-  const ctx = initializeContext({ ...params, processors: allProcessors });
-  processSchema(input, ctx);
-  extractDefs(ctx, input);
-  return finalize(ctx, input);
-}
 // node_modules/zod/v4/classic/errors.js
 var _installedErrorProtos = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);
 function _lazyMethod(proto, key, make) {
@@ -14610,76 +14401,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"]),
@@ -14916,7 +14647,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),
@@ -15092,14 +14824,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 = {
@@ -15138,7 +14871,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)
   }),
@@ -15192,6 +14928,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 = {
@@ -15225,103 +14970,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))
@@ -15410,6 +15058,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";
@@ -16464,7 +16508,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 {
@@ -16472,11 +16516,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;
 };
@@ -16747,13 +16791,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);
@@ -16777,7 +16821,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);
@@ -16796,7 +16840,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),
@@ -16818,7 +16862,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 ?? "")
@@ -16874,8 +16918,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);
@@ -17688,7 +17732,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 {
@@ -18034,11 +18078,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 {
@@ -18082,12 +18126,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()))
@@ -18289,7 +18333,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 };
@@ -18334,7 +18378,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;
     }
@@ -18505,10 +18549,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";
@@ -18748,6 +18792,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}"]));
 }
@@ -18839,53 +18884,622 @@ function worktreeSignal(cwd, options = {}) {
   }
   return `sig:${hash.digest("hex")}`;
 }
+function patchId(cwd, base, head) {
+  if (!safeArg(base) || !safeArg(head))
+    return 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/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)
+// 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 {
+    ok: run.status === 0,
+    stdout: run.stdout ?? "",
+    stderr: run.error ? String(run.error.message) : run.stderr ?? ""
+  };
+};
+var git3 = (cwd, args) => {
+  const run = gitRun2(cwd, args);
+  const value = run.ok ? run.stdout.trim() : "";
+  return value ? value : null;
+};
+var safeRef = (value) => value.length > 0 && !value.startsWith("-");
+function resolveCommit(cwd, ref) {
+  if (!safeRef(ref))
     return null;
-  if (value.includes("\\") || value.split("/").includes(".."))
+  return git3(cwd, ["rev-parse", "--verify", "-q", `${ref}^{commit}`]);
+}
+function branchHead(cwd, branch) {
+  if (!safeRef(branch))
     return null;
-  const normalized = path9.posix.normalize(value);
-  if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
+  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;
-  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 = 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 `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 {
-    description: scope.description,
-    paths: [...new Set(normalizedPaths)],
-    exclusions: [...new Set(normalizedExclusions)]
+    host: str2(actor.host) ?? "unknown",
+    session: str2(actor.session),
+    agentId: str2(actor.agentId)
   };
 };
-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;
+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 {
+    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}`);
+  }
+  const rows = [];
+  let skipped = 0;
+  for (const raw of text.split(`
+`)) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+      continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      skipped += 1;
+      continue;
+    }
+    if (!isRecord2(parsed) || !str2(parsed.id) || !str2(parsed.type) || !str2(parsed.at)) {
+      skipped += 1;
+      continue;
+    }
+    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 left.length - right.length;
-};
+  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;
+  }
+}
+
+// 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 = spawnSync5("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+  const result = spawnSync6("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
     cwd: root,
     encoding: "buffer"
   });
@@ -18897,21 +19511,21 @@ var gitPaths = (root) => {
       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" });
+  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(path9.sep).join("/")));
+    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 = fs10.readdirSync(directory);
+    names = fs11.readdirSync(directory);
   } catch {
     return true;
   }
@@ -18919,10 +19533,10 @@ var walk = (root, directory, output) => {
   for (const name of names) {
     if (name === ".git" || name === ".workit")
       continue;
-    const target = path9.join(directory, name);
+    const target = path11.join(directory, name);
     let stat;
     try {
-      stat = fs10.lstatSync(target);
+      stat = fs11.lstatSync(target);
     } catch {
       uncertain = true;
       continue;
@@ -18937,14 +19551,14 @@ var walk = (root, directory, output) => {
 var scopeRoots = (root, scope) => {
   const roots = [];
   for (const item of scope.paths.length ? scope.paths : ["."]) {
-    const target = path9.resolve(root, item);
+    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 (!fs10.existsSync(ancestor) && ancestor !== root)
-      ancestor = path9.dirname(ancestor);
+    while (!fs11.existsSync(ancestor) && ancestor !== root)
+      ancestor = path11.dirname(ancestor);
     try {
-      if (!inside(root, fs10.realpathSync(ancestor)))
+      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}`);
@@ -18956,7 +19570,7 @@ var scopeRoots = (root, scope) => {
 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");
   }
@@ -18974,11 +19588,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;
@@ -18994,17 +19608,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()) {
@@ -19029,7 +19643,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;
@@ -19169,7 +19783,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");
   }
@@ -19178,23 +19792,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: [
               {
@@ -19210,7 +19824,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");
@@ -19295,7 +19909,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 {
@@ -19710,14 +20352,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";
@@ -19776,7 +20418,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()) => {
@@ -19786,12 +20428,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;
   }
@@ -19799,9 +20441,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())
@@ -19872,7 +20514,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 = () => {
@@ -19917,8 +20559,9 @@ var resolveCommitPolicy = (config, workspace) => {
 };
 
 // packages/workit-core/src/core/workspaces.ts
+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");
@@ -19971,7 +20614,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"],
@@ -19990,6 +20633,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()
@@ -20030,6 +20674,72 @@ var workspacesFileSchema = object({ workspaces: array(workspaceConfigSchema).opt
     names.add(workspace.name);
   }
 });
+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` };
+  }
+  const validated = workspacesFileSchema.safeParse(parsed, { reportInput: true });
+  if (!validated.success) {
+    const detail = validated.error.issues.map((issue) => {
+      const field = String(issue.path[issue.path.length - 1] ?? "");
+      const attempted = ["provider", "preset", "strategy"].includes(field) && typeof issue.input === "string" ? ` (${JSON.stringify(issue.input)})` : "";
+      return `${issue.path.map(String).join(".") || "workspaces"}: ${issue.message}${attempted}`;
+    }).join("; ");
+    return {
+      status: "invalid",
+      path: file,
+      entries: [],
+      error: `${file} has invalid workspace configuration: ${detail}`
+    };
+  }
+  for (const [index, workspace] of (validated.data.workspaces ?? []).entries()) {
+    const glob = validateWorkspaceGlob(workspace.glob);
+    if (!glob.ok) {
+      return {
+        status: "invalid",
+        path: file,
+        entries: [],
+        error: `${file} workspaces.${index}.glob: ${glob.error}`
+      };
+    }
+  }
+  return {
+    status: "valid",
+    path: file,
+    entries: validated.data.workspaces ?? [],
+    document: parsed
+  };
+};
+var readWorkspacesResult = (dir = configDir()) => {
+  const file = path13.join(dir, "workspaces.json");
+  let raw;
+  try {
+    raw = readFileSync4(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return { status: "missing", path: file, entries: [], revision: workspacesRevision(null) };
+    return {
+      status: "malformed",
+      path: file,
+      entries: [],
+      error: `${file} could not be read: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return {
+      status: "malformed",
+      path: file,
+      entries: [],
+      revision: workspacesRevision(raw),
+      error: `${file} is not valid JSON`
+    };
+  }
+  return { ...validateWorkspacesDocument(parsed, file), revision: workspacesRevision(raw) };
+};
 var globToRegExp = (glob) => {
   let out = "";
   for (let i = 0;i < glob.length; i++) {
@@ -20127,6 +20837,30 @@ var selectWorkspaceMatch = (matches, cwd, workspaceName) => {
   }
   return mostSpecific[0];
 };
+var resolveWorkspaceFromEntries = (cwd, entries, workspaceName) => {
+  const targets = [cwd, realpathOf(cwd)].map((p) => p.replaceAll("\\", "/"));
+  const matches = [];
+  for (const ws of entries) {
+    const glob = ws.glob.replaceAll("\\", "/");
+    const canonical = canonicalGlob(glob);
+    let matched = false;
+    for (const target of targets) {
+      if (matchWorkspace(glob, target) || canonical !== glob && matchWorkspace(canonical, target)) {
+        matched = true;
+        break;
+      }
+    }
+    if (matched)
+      matches.push(ws);
+  }
+  return selectWorkspaceMatch(matches, cwd, workspaceName) ?? null;
+};
+var resolveWorkspaceFrom = (cwd, dir, workspaceName) => {
+  const result = readWorkspacesResult(dir);
+  if (result.status === "malformed" || result.status === "invalid")
+    throw new Error(result.error);
+  return resolveWorkspaceFromEntries(cwd, result.entries, workspaceName);
+};
 var runtimeWorkspacePolicySchema = (kind) => {
   const key = kind === "branch" ? "branchPolicy" : kind === "commit" ? "commitPolicy" : "vcs";
   const policySchema = kind === "branch" ? workspaceBranchPolicySchema : kind === "commit" ? workspaceCommitPolicySchema : object({
@@ -20149,7 +20883,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");
@@ -20212,13 +20946,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();
@@ -20255,7 +20989,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,
@@ -20305,7 +21039,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: {} };
   }
@@ -20371,7 +21105,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 ?? {},
@@ -20409,7 +21143,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"
   });
@@ -20425,7 +21159,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
@@ -20445,7 +21179,7 @@ function mergedPrStyle(limit = 6, cwd) {
       });
     }
   } else if (provider === "github") {
-    const r = spawnSync6("gh", [
+    const r = spawnSync7("gh", [
       "pr",
       "list",
       "--repo",
@@ -20494,305 +21228,34 @@ var resolveBranchPolicyFor = (workspaceRoot, profileName) => effectiveWorkspaceP
 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);
+function resolvePolicy(input) {
+  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" }]
     });
-  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;
-  });
-}
-function resolvePolicy(input) {
-  const normalized = normalizeResolverInput(input);
-  if (!normalized.ok)
-    return normalized;
-  const requirements = resolveRequirements(normalized.data);
   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");
@@ -20820,7 +21283,222 @@ 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";
+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,
@@ -21013,22 +21691,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,
@@ -21040,18 +21703,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;
 };
@@ -21068,6 +21719,7 @@ var importedTask = (source, bundle, destinationWorkspaceId, context, timestamp)
   for (const entry of [
     source.intent,
     ...source.assessments,
+    ...source.judgments ?? [],
     ...source.evidence,
     ...source.decisions,
     ...source.findings,
@@ -21091,9 +21743,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),
@@ -21161,6 +21820,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);
@@ -21230,7 +21890,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;
@@ -21484,7 +22145,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")
@@ -21495,16 +22160,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
       };
@@ -21706,9 +22372,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) ?? []);
@@ -21716,7 +22387,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
@@ -22075,16 +22746,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) {
@@ -22410,9 +23077,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);
@@ -22439,7 +23106,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(),
@@ -22450,11 +23117,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",
@@ -22468,11 +23135,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,
@@ -22546,7 +23213,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("/");
@@ -22577,8 +23244,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"));
@@ -22603,9 +23270,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("\\", "/"));
       }
     }
   };
@@ -22613,7 +23280,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(`
 `);
@@ -22621,7 +23288,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 = "";
@@ -22637,7 +23304,7 @@ function prReadyContext(root, range) {
   stdout += printSection("Repository");
   stdout += `root: ${cwd}
 `;
-  stdout += `branch: ${currentBranch(cwd)}
+  stdout += `branch: ${currentBranch2(cwd)}
 `;
   stdout += `range: ${range}
 `;
@@ -22679,7 +23346,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
 
@@ -22689,7 +23356,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"]);
@@ -22698,7 +23365,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.
 `;
   }
@@ -22731,7 +23398,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);
@@ -22741,7 +23408,7 @@ function changelogContext(root, range) {
   stdout += printSection("Repository");
   stdout += `root: ${cwd}
 `;
-  stdout += `branch: ${currentBranch(cwd)}
+  stdout += `branch: ${currentBranch2(cwd)}
 `;
   stdout += `range: ${resolvedRange}
 `;
@@ -22749,8 +23416,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 {
@@ -22769,7 +23436,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);
@@ -22779,7 +23446,7 @@ function docsRefreshContext(root, range) {
   stdout += printSection("Repository");
   stdout += `root: ${cwd}
 `;
-  stdout += `branch: ${currentBranch(cwd)}
+  stdout += `branch: ${currentBranch2(cwd)}
 `;
   stdout += `range: ${resolvedRange}
 `;
@@ -22791,8 +23458,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 {
@@ -22800,8 +23467,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) + `
@@ -22814,7 +23481,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 };
@@ -22828,7 +23495,7 @@ function releaseNotesContext(root, rangeOrTag) {
   stdout += printSection("Repository");
   stdout += `root: ${cwd}
 `;
-  stdout += `branch: ${currentBranch(cwd)}
+  stdout += `branch: ${currentBranch2(cwd)}
 `;
   stdout += `requested: ${rangeOrTag}
 `;
@@ -22852,7 +23519,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 + `
 `;
   }
@@ -22880,12 +23547,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);
@@ -22895,13 +23562,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 {}
     }
@@ -22910,7 +23577,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"
   });
@@ -22941,7 +23608,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 ?? "" }
@@ -23019,8 +23686,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();
@@ -23033,22 +23700,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 };
   }
@@ -23059,11 +23726,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" };
   }
@@ -23102,12 +23769,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)) {
@@ -23172,9 +23839,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];
@@ -23444,22 +24111,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 }
@@ -23483,8 +24150,8 @@ var SUPPORT_MATRIX = {
 };
 
 // packages/workit-mcp/src/server.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6, realpathSync as realpathSync6 } from "node:fs";
-import path17 from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync6, realpathSync as realpathSync6 } from "node:fs";
+import path20 from "node:path";
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
 function isZ4Schema(s) {
   const schema = s;
@@ -25863,7 +26530,7 @@ class StdioServerTransport {
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/workit-core/src/core/logger.ts
-import os3 from "node:os";
+import os4 from "node:os";
 var REDACTED = "[REDACTED]";
 var SECRET_VALUE = /\b(?:Bearer|Basic|Digest|Token)\s+\S+/gi;
 var KEY_EQ_VALUE = /\b([A-Za-z0-9_-]*(?:token|secret|password|passwd|apikey|api[_-]?key|authorization|credential|bearer)[A-Za-z0-9_-]*)([:=]\s*).+/gi;
@@ -25906,7 +26573,7 @@ var SENSITIVE_WORDS = new Set([
 ]);
 var STACK_WORDS = new Set(["stack", "stacktrace", "trace"]);
 var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-var homePattern = new RegExp(`${escapeRegExp(os3.homedir())}(?=[/\\\\]|$)|\\$HOME(?=[/\\\\]|$)`, "g");
+var homePattern = new RegExp(`${escapeRegExp(os4.homedir())}(?=[/\\\\]|$)|\\$HOME(?=[/\\\\]|$)`, "g");
 var applyPatterns = (value) => {
   let out = value;
   out = out.replace(SECRET_VALUE, REDACTED);
@@ -25957,13 +26624,13 @@ var rootVariants = (workspaceRoot) => {
   if (!workspaceRoot)
     return [];
   const roots = new Set;
-  for (const candidate of [workspaceRoot, path17.resolve(workspaceRoot)]) {
-    if (path17.isAbsolute(candidate) && candidate !== path17.parse(candidate).root)
+  for (const candidate of [workspaceRoot, path20.resolve(workspaceRoot)]) {
+    if (path20.isAbsolute(candidate) && candidate !== path20.parse(candidate).root)
       roots.add(candidate);
   }
   try {
     const canonical = realpathSync6(workspaceRoot);
-    if (canonical !== path17.parse(canonical).root)
+    if (canonical !== path20.parse(canonical).root)
       roots.add(canonical);
   } catch {}
   return [...roots].toSorted((left, right) => right.length - left.length);
@@ -25985,39 +26652,20 @@ function assertMcpHost(host) {
     throw new Error("MCP host must be cursor, codex_cli, or codex_desktop");
   }
 }
-var operationDescription = (family) => `Workit ${family} operations. Inputs are validated by the shared Workit contract.`;
-var READ_ONLY_ACTIONS = new Set(["list", "inspect", "preview", "explain", "export"]);
-var requiresCallerIdentity = (input) => typeof input !== "object" || input === null || !READ_ONLY_ACTIONS.has(String(input.action));
-var toolInputSchema = (family) => {
-  const schema = boundedOperationJsonSchema(family);
-  return { type: "object", ...schema };
-};
-var schemaBranches = (schema) => Array.isArray(schema.oneOf) ? schema.oneOf : Array.isArray(schema.anyOf) ? schema.anyOf : [schema];
-var readOnlyBranches = (family) => schemaBranches(boundedOperationJsonSchema(family)).filter((branch) => {
-  const action = branch.properties?.action?.const;
-  return typeof action === "string" && READ_ONLY_ACTIONS.has(action);
-});
-var advertisedToolSchemas = (attested) => {
-  if (attested)
-    return OPERATION_FAMILIES.map((family) => ({
+var READ_ONLY_ACTIONS2 = new Set(["list", "inspect", "preview", "explain", "export"]);
+var requiresCallerIdentity = (input) => typeof input !== "object" || input === null || !READ_ONLY_ACTIONS2.has(String(input.action));
+var advertisedToolSchemas = (attested) => OPERATION_FAMILIES.flatMap((family) => {
+  const schema = flatOperationJsonSchema(family, { readOnly: !attested });
+  if (!schema)
+    return [];
+  return [
+    {
       name: `workit_${family}`,
-      description: operationDescription(family),
-      inputSchema: toolInputSchema(family)
-    }));
-  return OPERATION_FAMILIES.flatMap((family) => {
-    const branches = readOnlyBranches(family);
-    if (!branches.length)
-      return [];
-    const schema = boundedOperationJsonSchema(family);
-    return [
-      {
-        name: `workit_${family}`,
-        description: `${operationDescription(family)} Unattested MCP callers can only run read-only actions; mutating operations require an attested host session.`,
-        inputSchema: { type: "object", ...schema, oneOf: branches }
-      }
-    ];
-  });
-};
+      description: attested ? operationDescription(family) : `${operationDescription(family)} Unattested MCP callers can only run read-only actions; mutating operations require an attested host session.`,
+      inputSchema: schema
+    }
+  ];
+});
 var sanitizeFailure = (result, workspaceRoot) => {
   if (result.ok)
     return result;
@@ -26064,12 +26712,12 @@ var thrownResult = (tool, error, workspaceRoot) => {
 };
 function createMcpServer(host, contextProvider) {
   assertMcpHost(host);
-  const here = path17.dirname(fileURLToPath2(import.meta.url));
+  const here = path20.dirname(fileURLToPath2(import.meta.url));
   const sourceMarker = markSourcesLoaded([
-    path17.join(here, "server.ts"),
-    path17.join(here, "..", "..", "workit-core", "src", "core", "task-contract.ts"),
-    path17.join(here, "..", "..", "workit-core", "src", "core", "task-engine.ts")
-  ].filter((file) => existsSync7(file)));
+    path20.join(here, "server.ts"),
+    path20.join(here, "..", "..", "workit-core", "src", "core", "task-contract.ts"),
+    path20.join(here, "..", "..", "workit-core", "src", "core", "task-engine.ts")
+  ].filter((file) => existsSync8(file)));
   let staleWarned = false;
   const server = new Server({ name: "workit", version: VERSION }, { capabilities: { tools: {}, resources: {} } });
   server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -26193,7 +26841,7 @@ function createMcpServer(host, contextProvider) {
           details: { operation: family }
         }, workspaceRoot);
       }
-      const parsed = parseOperation(family, request.params.arguments);
+      const parsed = parseAdvertisedOperation(family, request.params.arguments, host);
       if (!parsed.ok)
         return resultForClient(parsed, workspaceRoot);
       if (context.callerAttested !== true && requiresCallerIdentity(parsed.data))
@@ -26260,12 +26908,34 @@ var capabilitiesFor = (descriptor, observed = {}) => descriptor.capabilities.map
 // packages/workit-core/src/hooks/context.ts
 var signals = new Map;
 var cache = new Map;
+// packages/workit-core/src/hooks/write-gate.ts
+var CASE_INSENSITIVE = process.platform === "darwin" || process.platform === "win32";
+var PREFIXES = new Set(["sudo", "command", "env", "nohup", "time", "exec", "xargs"]);
+var cache2 = new Map;
+// 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"]);
@@ -26287,6 +26957,7 @@ var CODEX_DESCRIPTOR = {
     "context.turn": undocumented,
     "shell.pre": { support: "native", native: "PreToolUse" },
     "tool.pre": { support: "native", native: "PreToolUse" },
+    "write.pre": { support: "undocumented", native: null },
     "shell.post": undocumented,
     "subagent.start": { support: "native", native: "SubagentStart" },
     "subagent.stop": { support: "native", native: "SubagentStop" },
@@ -26399,8 +27070,8 @@ var codexQualification = (host) => host === "codex_cli" ? { surface: host, cli:
 var resolveCodexWorkspaceRoot = (pluginRoot, env) => {
   const explicit = env.WORKFLOW_WORKSPACE_ROOT;
   const inherited = env.PWD;
-  const candidate = explicit ?? (inherited && path18.resolve(inherited) !== path18.resolve(pluginRoot) ? inherited : undefined);
-  if (!candidate || !path18.isAbsolute(candidate) || !existsSync8(candidate))
+  const candidate = explicit ?? (inherited && path21.resolve(inherited) !== path21.resolve(pluginRoot) ? inherited : undefined);
+  if (!candidate || !path21.isAbsolute(candidate) || !existsSync9(candidate))
     return null;
   try {
     if (!statSync3(candidate).isDirectory())