@brainervirus/workit-pi 6.0.1 → 7.1.0

package/dist/workit.js

@@ -3,9 +3,9 @@ import { randomUUID as randomUUID5 } from "node:crypto";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // 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 spawnSync12 } 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";
@@ -7429,6 +7429,14 @@ function object(shape, params) {
   };
   return new ZodObject(def);
 }
+function looseObject(shape, params) {
+  return new ZodObject({
+    type: "object",
+    shape,
+    catchall: unknown(),
+    ...normalizeParams(params)
+  });
+}
 var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
   $ZodUnion.init(inst, def);
   ZodType.init(inst, def);
@@ -7929,76 +7937,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"]),
@@ -8235,7 +8183,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),
@@ -8411,14 +8360,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 = {
@@ -8457,7 +8407,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)
   }),
@@ -8511,6 +8464,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 = {
@@ -8544,103 +8506,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))
@@ -8729,6 +8594,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";
@@ -9783,7 +10044,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 {
@@ -9791,11 +10052,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;
 };
@@ -10066,13 +10327,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);
@@ -10096,7 +10357,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);
@@ -10115,7 +10376,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),
@@ -10137,7 +10398,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 ?? "")
@@ -10193,8 +10454,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);
@@ -11007,7 +11268,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 {
@@ -11353,11 +11614,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 {
@@ -11401,12 +11662,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()))
@@ -11608,7 +11869,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 };
@@ -11653,7 +11914,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;
     }
@@ -11824,10 +12085,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";
@@ -12067,6 +12328,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}"]));
 }
@@ -12158,124 +12420,733 @@ function worktreeSignal(cwd, options = {}) {
   }
   return `sig:${hash.digest("hex")}`;
 }
-
-// packages/workit-core/src/core/task-evaluation.ts
-var digestBytes = (value) => createHash6("sha256").update(value).digest("hex");
-var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path9.sep}`);
-var relative = (root, candidate) => path9.relative(root, candidate).split(path9.sep).join("/") || ".";
-var canonicalPath = (value) => {
-  if (typeof value !== "string" || !value)
+function mergeBase(cwd, a, b) {
+  if (!safeArg(a) || !safeArg(b))
     return null;
-  if (value.includes("\\") || value.split("/").includes(".."))
+  return line(git2(cwd, ["merge-base", a, b]));
+}
+function patchId(cwd, base, head) {
+  if (!safeArg(base) || !safeArg(head))
     return null;
-  const normalized = path9.posix.normalize(value);
-  if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
+  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;
-  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 id = git2(cwd, ["patch-id", "--stable"], { input: diff.stdout });
+  return line(id)?.split(/\s+/u)[0] ?? null;
+}
+function remoteNames(cwd) {
+  return (git2(cwd, ["remote"]).stdout ?? "").split(/\r?\n/u).map((value) => value.trim()).filter(Boolean);
+}
+function resolveRef(cwd, ref) {
+  if (!safeArg(ref))
     return null;
+  return line(git2(cwd, ["rev-parse", "--verify", "-q", `${ref}^{commit}`]));
+}
+var config2 = (cwd, key) => line(git2(cwd, ["config", "--get", key]));
+function currentBranch(cwd) {
+  return line(git2(cwd, ["symbolic-ref", "--short", "-q", "HEAD"]));
+}
+function pushRemoteName(cwd, branch) {
+  const name = branch ?? currentBranch(cwd);
+  const remotes = remoteNames(cwd);
+  const candidates = [
+    name ? config2(cwd, `branch.${name}.pushRemote`) : null,
+    config2(cwd, "remote.pushDefault"),
+    name ? config2(cwd, `branch.${name}.remote`) : null
+  ];
+  for (const candidate of candidates)
+    if (candidate && candidate !== "." && remotes.includes(candidate))
+      return candidate;
+  if (remotes.includes("origin"))
+    return "origin";
+  return remotes.length === 1 ? remotes[0] : null;
+}
+
+// packages/workit-core/src/core/policy/derive.ts
+import { existsSync as existsSync3 } from "node:fs";
+import path10 from "node:path";
+
+// packages/workit-core/src/ledger.ts
+import { spawnSync as spawnSync5 } from "node:child_process";
+import { createHash as createHash6, randomBytes as randomBytes2 } from "node:crypto";
+import fs10 from "node:fs";
+import path9 from "node:path";
+var LEDGER_VERSION = 1;
+var PASSING = new Set(["verified", "tests-verified", "type-check-only"]);
+var FAILING = new Set(["failed", "blocked"]);
+var STRONG_RESULTS = new Set(["verified", "tests-verified"]);
+var PR_ROW_TYPES = new Set(["pr.created", "pr.status", "pr.merged"]);
+var err = (code, error, unblock) => ({
+  ok: false,
+  code,
+  error,
+  ...unblock ? { unblock } : {}
+});
+var gitRun2 = (cwd, args, timeoutMs = GIT_TIMEOUTS.local) => {
+  const run = spawnSync5("git", args, {
+    cwd,
+    encoding: "utf8",
+    timeout: timeoutMs,
+    killSignal: "SIGKILL",
+    windowsHide: true,
+    maxBuffer: 256 * 1024 * 1024,
+    env: {
+      ...process.env,
+      GIT_TERMINAL_PROMPT: "0",
+      GIT_OPTIONAL_LOCKS: "0",
+      LC_ALL: "C",
+      LANGUAGE: "C"
+    }
+  });
   return {
-    description: scope.description,
-    paths: [...new Set(normalizedPaths)],
-    exclusions: [...new Set(normalizedExclusions)]
+    ok: run.status === 0,
+    stdout: run.stdout ?? "",
+    stderr: run.error ? String(run.error.message) : run.stderr ?? ""
   };
 };
-var excluded = (value, exclusions) => exclusions.some((item) => item === value || item !== "." && value.startsWith(`${item}/`));
-var scopeMatches = (value, scope) => {
-  const normalized = canonicalScope(scope);
-  if (!normalized)
-    return false;
-  const paths = normalized.paths;
-  return paths.some((item) => item === "." || value === item || value.startsWith(`${item}/`)) && !excluded(value, normalized.exclusions);
-};
-var pathRelevant = (value, scope) => scopeMatches(value, scope);
-var compareCodeUnits2 = (left, right) => {
-  const length = Math.min(left.length, right.length);
-  for (let index = 0;index < length; index += 1) {
-    const difference = left.charCodeAt(index) - right.charCodeAt(index);
-    if (difference !== 0)
-      return difference;
-  }
-  return left.length - right.length;
+var git3 = (cwd, args) => {
+  const run = gitRun2(cwd, args);
+  const value = run.ok ? run.stdout.trim() : "";
+  return value ? value : null;
 };
-var gitPaths = (root) => {
-  const result = spawnSync5("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
-    cwd: root,
-    encoding: "buffer"
-  });
-  if (result.status !== 0) {
-    const stderr = result.stderr?.toString("utf8") ?? "";
-    return {
-      paths: [],
-      uncertain: !/not a git repository/i.test(stderr),
-      git: !/not a git repository/i.test(stderr)
-    };
-  }
-  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path9.sep).join("/")) : [];
-  const stagedDeleted = spawnSync5("git", ["diff", "--cached", "--name-only", "--diff-filter=D", "-z"], { cwd: root, encoding: "buffer" });
-  if (stagedDeleted.status !== 0) {
-    const stderr = stagedDeleted.stderr?.toString("utf8") ?? "";
-    if (!/not a git repository/i.test(stderr))
-      return { paths, uncertain: true, git: true };
-  } else if (stagedDeleted.stdout) {
-    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path9.sep).join("/")));
+var safeRef = (value) => value.length > 0 && !value.startsWith("-");
+function resolveCommit(cwd, ref) {
+  if (!safeRef(ref))
+    return null;
+  return git3(cwd, ["rev-parse", "--verify", "-q", `${ref}^{commit}`]);
+}
+function branchHead(cwd, branch) {
+  if (!safeRef(branch))
+    return null;
+  return resolveCommit(cwd, `refs/heads/${branch}`) ?? resolveCommit(cwd, `refs/remotes/origin/${branch}`);
+}
+function defaultBase(cwd) {
+  const originHead = git3(cwd, ["symbolic-ref", "-q", "--short", "refs/remotes/origin/HEAD"]);
+  if (originHead && resolveCommit(cwd, originHead))
+    return originHead;
+  for (const candidate of ["origin/main", "origin/master", "main", "master"])
+    if (resolveCommit(cwd, candidate))
+      return candidate;
+  return null;
+}
+function diffHash(cwd, base, head) {
+  if (!safeRef(base) || !safeRef(head))
+    return null;
+  const diff = gitRun2(cwd, [
+    "diff",
+    "-U3",
+    "--diff-algorithm=myers",
+    "--indent-heuristic",
+    "--no-color",
+    "--no-ext-diff",
+    "--no-textconv",
+    "--no-renames",
+    "--full-index",
+    "--binary",
+    "--src-prefix=a/",
+    "--dst-prefix=b/",
+    `${base}...${head}`,
+    "--"
+  ], GIT_TIMEOUTS.worktree);
+  if (!diff.ok || !diff.stdout)
+    return null;
+  const hash = createHash6("sha256");
+  for (const line of diff.stdout.split(`
+`)) {
+    if (line.startsWith("index "))
+      continue;
+    hash.update(line.startsWith("@@ ") ? "@@" : line);
+    hash.update(`
+`);
   }
-  return { paths: [...new Set(paths)], uncertain: false, git: true };
+  return `sha256:${hash.digest("hex")}`;
+}
+function storeRoot(cwd) {
+  const location = resolveStore(path9.resolve(cwd));
+  if (location instanceof Error)
+    return err("unavailable", location.message.replace(/; fix the repository.*$/u, ""), "fix the repository (git status should work here) or run from a non-git directory");
+  return { ok: true, value: { root: location.dir, shared: location.shared } };
+}
+function ledgerPath(cwd) {
+  const root = storeRoot(cwd);
+  return root.ok ? { ok: true, value: path9.join(root.value.root, "ledger", "ledger.jsonl") } : root;
+}
+var NETWORK_FS_TYPES = new Set([
+  26985,
+  20859,
+  4266872130,
+  4283649346,
+  1702057286,
+  1397113167,
+  12805120,
+  16914839,
+  1196443219,
+  198183888
+]);
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var str2 = (value) => typeof value === "string" ? value : null;
+var normalizeActor = (value) => {
+  const actor = isRecord2(value) ? value : {};
+  return {
+    host: str2(actor.host) ?? "unknown",
+    session: str2(actor.session),
+    agentId: str2(actor.agentId)
+  };
 };
-var walk = (root, directory, output) => {
-  let names;
+function supersedeAllowed(by, target) {
+  if (by.type !== target.type)
+    return `a ${by.type} row cannot supersede a ${target.type} row`;
+  if (!by.actor.session || by.actor.session !== target.actor.session)
+    return "only the session that wrote a row can supersede it";
+  if (by.type === "verdict" && by.self === true && target.self !== true)
+    return "a self verdict cannot replace an independent verdict";
+  return null;
+}
+function readLedger(cwd) {
+  const file = ledgerPath(cwd);
+  if (!file.ok)
+    return file;
+  let text = "";
   try {
-    names = fs10.readdirSync(directory);
-  } catch {
-    return true;
-  }
-  let uncertain = false;
-  for (const name of names) {
-    if (name === ".git" || name === ".workit")
+    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;
-    const target = path9.join(directory, name);
-    let stat;
+    let parsed;
     try {
-      stat = fs10.lstatSync(target);
+      parsed = JSON.parse(trimmed);
     } catch {
-      uncertain = true;
+      skipped += 1;
       continue;
     }
-    const item = relative(root, target);
-    output.add(item);
-    if (stat.isDirectory() && !stat.isSymbolicLink())
-      uncertain = walk(root, target, output) || uncertain;
-  }
-  return uncertain;
-};
-var scopeRoots = (root, scope) => {
-  const roots = [];
-  for (const item of scope.paths.length ? scope.paths : ["."]) {
-    const target = path9.resolve(root, item);
-    if (!inside(root, target))
-      return failure2("invalid_input", `candidate scope escapes checkout: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} is outside the checkout` }] });
-    let ancestor = target;
-    while (!fs10.existsSync(ancestor) && ancestor !== root)
-      ancestor = path9.dirname(ancestor);
-    try {
-      if (!inside(root, fs10.realpathSync(ancestor)))
-        return failure2("invalid_input", `candidate scope escapes checkout through a symlink: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} resolves outside the checkout` }] });
-    } catch {
-      return failure2("invalid_input", `candidate scope cannot be inspected: ${item}`);
+    if (!isRecord2(parsed) || !str2(parsed.id) || !str2(parsed.type) || !str2(parsed.at)) {
+      skipped += 1;
+      continue;
     }
-    roots.push(target);
+    const pr = typeof parsed.pr === "number" && Number.isInteger(parsed.pr) ? parsed.pr : undefined;
+    rows.push({
+      ...parsed,
+      v: typeof parsed.v === "number" ? parsed.v : LEDGER_VERSION,
+      id: parsed.id,
+      at: parsed.at,
+      type: parsed.type,
+      actor: normalizeActor(parsed.actor),
+      branch: str2(parsed.branch),
+      head: str2(parsed.head),
+      base: str2(parsed.base),
+      baseSha: str2(parsed.baseSha),
+      patchId: str2(parsed.patchId),
+      diffHash: str2(parsed.diffHash),
+      tree: str2(parsed.tree),
+      dirty: typeof parsed.dirty === "boolean" ? parsed.dirty : null,
+      ...pr === undefined ? {} : { pr },
+      ...str2(parsed.supersedes) ? { supersedes: parsed.supersedes } : {},
+      seq: rows.length + 1,
+      superseded: false,
+      supersedeIgnored: false
+    });
   }
-  return success(null, null, roots);
-};
-function captureCandidate(root, scope, environment = []) {
-  let checkout;
+  const byId = new Map;
+  for (const row of rows) {
+    const target = row.supersedes ? byId.get(row.supersedes) : undefined;
+    if (target && supersedeAllowed(row, target) === null)
+      target.superseded = true;
+    else if (row.supersedes)
+      row.supersedeIgnored = true;
+    if (!byId.has(row.id))
+      byId.set(row.id, row);
+  }
+  return { ok: true, value: { path: file.value, rows, skipped } };
+}
+function verdictBasis(verdict, current) {
+  if (verdict.head && verdict.head === current.head)
+    return "fresh";
+  if (verdict.patchId && verdict.patchId === current.patchId && verdict.diffHash && verdict.diffHash === current.diffHash)
+    return "carried";
+  return "stale";
+}
+var isLiveVerdict = (row) => row.type === "verdict" && typeof row.result === "string" && !row.superseded;
+function trailerSessions(cwd, base, head) {
+  if (!base || !head || !safeRef(base) || !safeRef(head))
+    return [];
+  const out = git3(cwd, [
+    "log",
+    "--format=%(trailers:key=Workit-Session,valueonly,separator=%x00)",
+    `${base}..${head}`
+  ]);
+  return (out ?? "").split(/[\0\n]/u).map((value) => value.trim()).filter(Boolean);
+}
+function authorSessions(cwd, rows, branch, range = { base: null, head: null }) {
+  const sessions = new Set;
+  for (const row of rows) {
+    if (row.branch !== branch || row.type !== "commit.recorded" && row.type !== "task.opened")
+      continue;
+    const session = str2(row.session) ?? row.actor.session;
+    if (session)
+      sessions.add(session);
+  }
+  for (const session of trailerSessions(cwd, range.base, range.head))
+    sessions.add(session);
+  return sessions;
+}
+var independenceReasons = (row, authors) => {
+  const reasons = [];
+  if (!row.actor.session)
+    reasons.push("no_session");
+  else if (authors.has(row.actor.session))
+    reasons.push("author_session");
+  if (row.self === true && !reasons.includes("no_session"))
+    reasons.push("self");
+  return reasons;
+};
+function effectiveOf(rows, authors) {
+  let effective = null;
+  for (const row of rows) {
+    if (!effective) {
+      effective = row;
+      continue;
+    }
+    const rowIndependent = independenceReasons(row, authors).length === 0;
+    const effIndependent = independenceReasons(effective, authors).length === 0;
+    if (effIndependent && !rowIndependent)
+      continue;
+    if (effIndependent && FAILING.has(String(effective.result)) && row.actor.session === effective.actor.session)
+      continue;
+    effective = row;
+  }
+  return effective;
+}
+function restackCarries(rows, branch, from, to) {
+  if (!from || !to)
+    return false;
+  const edges = new Map;
+  for (const row of rows)
+    if (row.type === "stack.restacked" && row.observer === "workit_cli" && row.branch === branch && row.patchEqual === true && typeof row.fromHead === "string" && row.head)
+      edges.set(row.fromHead, [...edges.get(row.fromHead) ?? [], row.head]);
+  const seen = new Set([from]);
+  const queue = [from];
+  while (queue.length) {
+    const next = queue.shift();
+    if (next === to)
+      return true;
+    for (const target of edges.get(next) ?? [])
+      if (!seen.has(target)) {
+        seen.add(target);
+        queue.push(target);
+      }
+  }
+  return false;
+}
+function checkVerdicts(cwd, branch, rows) {
+  const head = branchHead(cwd, branch);
+  const fallbackBase = defaultBase(cwd);
+  const keyCache = new Map;
+  const keyFor = (base) => {
+    if (!base || !head)
+      return { patchId: null, diffHash: null };
+    let key = keyCache.get(base);
+    if (!key) {
+      key = { patchId: patchId(cwd, base, head), diffHash: diffHash(cwd, base, head) };
+      keyCache.set(base, key);
+    }
+    return key;
+  };
+  const authors = authorSessions(cwd, rows, branch, { base: fallbackBase, head });
+  const byKind = new Map;
+  for (const row of rows)
+    if (row.branch === branch && isLiveVerdict(row)) {
+      const kind = typeof row.kind === "string" ? row.kind : "review";
+      byKind.set(kind, [...byKind.get(kind) ?? [], row]);
+    }
+  const verdicts = [];
+  for (const [kind, list] of byKind) {
+    const row = effectiveOf(list, authors);
+    if (!row)
+      continue;
+    let basis = verdictBasis(row, { head, ...keyFor(row.base ?? fallbackBase) });
+    if (basis === "stale" && restackCarries(rows, branch, row.head, head))
+      basis = "carried";
+    const current = basis !== "stale";
+    const independence = independenceReasons(row, authors);
+    const reasons = [
+      ...current ? [] : ["stale"],
+      ...PASSING.has(String(row.result)) ? [] : ["not_passing"],
+      ...independence
+    ];
+    verdicts.push({
+      kind,
+      basis,
+      current,
+      independent: independence.length === 0,
+      accepted: reasons.length === 0,
+      reasons,
+      verdict: row
+    });
+  }
+  verdicts.sort((a, b) => a.verdict.seq - b.verdict.seq);
+  const newestCurrent = verdicts.findLast((entry) => entry.current) ?? verdicts.at(-1) ?? null;
+  const failing = verdicts.find((entry) => entry.current && entry.independent && FAILING.has(String(entry.verdict.result)));
+  const newestAccepted = verdicts.findLast((entry) => entry.accepted) ?? null;
+  const accepted = newestAccepted && !failing ? { accepted: true, verdict: newestAccepted.verdict, reasons: [] } : {
+    accepted: false,
+    verdict: failing?.verdict ?? null,
+    reasons: failing ? ["failing_verdict"] : newestCurrent?.reasons ?? ["no_verdict"]
+  };
+  const selfEntry = failing ? undefined : verdicts.findLast((entry) => entry.current && !entry.independent && STRONG_RESULTS.has(String(entry.verdict.result)));
+  return {
+    branch,
+    head,
+    review: accepted.accepted ? "verified" : selfEntry ? "self-reviewed" : "unreviewed",
+    selfVerdict: accepted.accepted ? null : selfEntry?.verdict ?? null,
+    base: newestCurrent?.verdict.base ?? fallbackBase,
+    patchId: keyFor(newestCurrent?.verdict.base ?? fallbackBase).patchId,
+    current: { basis: newestCurrent?.basis ?? "none", verdict: newestCurrent?.verdict ?? null },
+    accepted,
+    verdicts,
+    authors: [...authors].toSorted()
+  };
+}
+var OBSERVED_ONLY = new Set(["check", ...PR_ROW_TYPES]);
+
+// packages/workit-core/src/core/policy/derive.ts
+var RULES = {
+  test: "check:test",
+  self: "verdict:self",
+  nonAuthor: "verdict:non-author",
+  verified: "verdict:verified",
+  product: "decision:product",
+  plan: "plan"
+};
+var derived2 = (spec) => ({
+  ...spec,
+  id: requirementId({
+    ruleId: spec.ruleId,
+    scope: spec.scope,
+    satisfaction: spec.satisfaction,
+    before: spec.before,
+    dependentAction: spec.dependentAction
+  })
+});
+var sorted = (values) => [...new Set(values)].toSorted();
+var normalizedScope = (scope) => ({
+  description: scope.description,
+  paths: sorted(scope.paths),
+  exclusions: sorted(scope.exclusions)
+});
+function deriveRequirements(judgment, scope, constraints, verification = "self") {
+  const out = [];
+  const base = { scope, dependentAction: null };
+  if (judgment.behaviorChange)
+    out.push(derived2({
+      ...base,
+      ruleId: RULES.test,
+      dimension: "testing",
+      reason: "Behavior changes: the configured test check must pass on the final tree.",
+      satisfaction: "Run `workit check test` on the final tree.",
+      before: "close",
+      acceptanceAllowed: false
+    }));
+  if (judgment.behaviorChange && judgment.riskTier === "normal")
+    out.push(verification === "independent" ? derived2({
+      ...base,
+      ruleId: RULES.nonAuthor,
+      dimension: "review",
+      reason: "This workspace requires independent verification: a session that did not author the change records the verdict.",
+      satisfaction: "An independent session records a passing verdict: `workit ledger verdict verified --how <what it exercised>`.",
+      before: "close",
+      acceptanceAllowed: false
+    }) : derived2({
+      ...base,
+      ruleId: RULES.self,
+      dimension: "review",
+      reason: "A behavior change needs a recorded verdict; the author's own is allowed and is shown as self-reviewed, never verified.",
+      satisfaction: "After an observed passing `workit check test`, record `workit ledger verdict tests-verified --self --how <what you ran>` (or have a verifier record one).",
+      before: "close",
+      acceptanceAllowed: false
+    }));
+  if (judgment.riskTier === "high")
+    out.push(derived2({
+      ...base,
+      ruleId: RULES.verified,
+      dimension: "review",
+      reason: "High risk: an independent verifier must exercise the live surface.",
+      satisfaction: "An independent verifier runs the real surface and records `workit ledger verdict verified --kind live --how <what it exercised>`.",
+      before: "close",
+      acceptanceAllowed: false
+    }));
+  if (judgment.productChoiceOpen)
+    out.push(derived2({
+      ...base,
+      ruleId: RULES.product,
+      dimension: "decisions",
+      reason: "A product or preference choice is open; the user decides it before code is written.",
+      satisfaction: 'Ask the user (with your recommendation), then record the answer: `workit ledger decision "<choice>" --why "<reason>"`.',
+      before: "write",
+      acceptanceAllowed: false
+    }));
+  if (judgment.needsPlan || judgment.riskTier === "high")
+    out.push(derived2({
+      ...base,
+      ruleId: RULES.plan,
+      dimension: "artifacts",
+      reason: judgment.needsPlan ? "The work needs a written plan or spec before implementation." : "High-risk work needs a written plan before implementation.",
+      satisfaction: "Write the plan or spec (e.g. docs/plans/<slug>.md; docs and Markdown writes stay allowed), then record it: `workit policy assess --ref <path>`.",
+      before: "write",
+      acceptanceAllowed: true
+    }));
+  for (const constraint of constraints)
+    for (const obligation of constraint.requires)
+      out.push(derived2({
+        ruleId: `project-constraint:${constraint.id}:${obligation.kind}:${sha256({
+          kind: obligation.kind,
+          scope: normalizedScope(obligation.scope),
+          refs: obligation.refs.map((ref) => JSON.stringify(ref)).toSorted(),
+          method: obligation.method,
+          before: obligation.before,
+          dependentAction: obligation.dependentAction
+        })}`,
+        dimension: obligation.method ?? (obligation.kind === "check" ? "verification" : obligation.kind === "decision" ? "decisions" : "challenge"),
+        scope: obligation.scope,
+        reason: `${constraint.kind} constraint requires ${obligation.kind}: ${constraint.statement}`,
+        satisfaction: `Satisfy the constraint obligation using its referenced ${obligation.kind}.`,
+        before: obligation.before,
+        dependentAction: obligation.dependentAction,
+        acceptanceAllowed: constraint.acceptanceAllowed && obligation.kind !== "decision"
+      }));
+  const seen = new Set;
+  return out.filter((item) => seen.has(item.id) ? false : (seen.add(item.id), true));
+}
+var latestJudgment = (task) => task.judgments?.at(-1)?.data ?? null;
+var ledgerView = (root) => {
+  let branch;
+  let rows;
+  return {
+    branch: () => branch === undefined ? branch = currentBranch(root) : branch,
+    rows: () => {
+      if (rows === undefined) {
+        const read = readLedger(root);
+        rows = read.ok ? read.value.rows : [];
+      }
+      return rows;
+    }
+  };
+};
+var productDecision = (task, ledger) => {
+  const decisions = task.decisions.filter((entry) => entry.data.revoked === null && (entry.data.response === "approved" || entry.data.response === "stated") && entry.data.purpose !== "limitation");
+  if (decisions.length)
+    return {
+      met: true,
+      reason: "the user's decision is recorded on the task",
+      decisionIds: decisions.map((entry) => entry.id)
+    };
+  const since = Date.parse(task.createdAt);
+  const branch = ledger.branch();
+  const row = ledger.rows().findLast((item) => item.type === "decision" && !item.superseded && (item.branch ?? null) === branch && Date.parse(item.at) >= since);
+  return row ? { met: true, reason: `ledger decision ${row.id} records the choice`, decisionIds: [] } : {
+    met: false,
+    reason: 'open product choice: ask the user, then `workit ledger decision "<choice>" --why "<reason>"` (or re-judge productChoiceOpen=false if it is not open)',
+    decisionIds: []
+  };
+};
+var planRecorded = (task, root) => {
+  const cited = (latestJudgment(task)?.refs ?? []).find((ref) => ref.kind === "external" || ref.kind === "file" && existsSync3(path10.resolve(root, ref.path)));
+  if (cited)
+    return {
+      met: true,
+      reason: `plan recorded: ${cited.kind === "file" ? cited.path : cited.kind === "external" ? cited.url : ""}`,
+      decisionIds: []
+    };
+  const artifact = task.evidence.some((entry) => entry.data.kind === "artifact" && entry.data.result === "passed");
+  return artifact ? { met: true, reason: "a passing artifact records the plan", decisionIds: [] } : {
+    met: false,
+    reason: "no plan recorded: write it (docs/ and Markdown writes stay allowed), then `workit policy assess --ref <path>`",
+    decisionIds: []
+  };
+};
+var verdict = (requirement, root, ledger) => {
+  const branch = ledger.branch();
+  if (!branch)
+    return { met: false, reason: "no branch is checked out to hold a verdict", decisionIds: [] };
+  const check = checkVerdicts(root, branch, ledger.rows());
+  const failing = check.accepted.reasons.includes("failing_verdict");
+  const strong = (entry) => STRONG_RESULTS.has(String(entry.verdict.result));
+  const met = !failing && (requirement.ruleId === RULES.verified ? check.verdicts.find((entry) => entry.accepted && entry.kind === "live" && String(entry.verdict.result) === "verified") : requirement.ruleId === RULES.nonAuthor ? check.verdicts.find((entry) => entry.accepted && strong(entry)) : check.verdicts.find((entry) => entry.current && strong(entry)));
+  if (met)
+    return {
+      met: true,
+      reason: `${met.accepted ? "accepted independent" : "self-reviewed (author's own)"} ${String(met.verdict.result)} verdict ${met.verdict.id}`,
+      decisionIds: []
+    };
+  const why = failing ? "a current independent verdict fails" : check.verdicts.some((entry) => entry.current && entry.verdict.result === "type-check-only") ? "type-check-only does not prove a behavior change" : (check.accepted.reasons.join(", ") || "no_verdict").replace(/_/g, " ");
+  const unblock = requirement.ruleId === RULES.self ? "record your own verdict after an observed `workit check test`: `workit ledger verdict tests-verified --self --how <what you ran>` (shown as self-reviewed), or have a verifier record one" : `an independent session records \`workit ledger verdict verified${requirement.ruleId === RULES.verified ? " --kind live" : ""} --how <what it exercised>\``;
+  return { met: false, reason: `${why}: ${unblock}`, decisionIds: [] };
+};
+function derivedRuleStatus(task, requirement, root, ledger) {
+  switch (requirement.ruleId) {
+    case RULES.product:
+      return productDecision(task, ledger);
+    case RULES.plan:
+      return planRecorded(task, root);
+    case RULES.self:
+    case RULES.nonAuthor:
+    case RULES.verified:
+      return verdict(requirement, root, ledger);
+    default:
+      return null;
+  }
+}
+function writeBlockers(task, root) {
+  if (task.status === "closed" || !task.policy)
+    return [];
+  const ledger = ledgerView(root);
+  return task.policy.requirements.flatMap((requirement) => {
+    if (requirement.before !== "write")
+      return [];
+    const status = derivedRuleStatus(task, requirement, root, ledger);
+    return status && !status.met ? [{ ruleId: requirement.ruleId, reason: status.reason }] : [];
+  });
+}
+
+// packages/workit-core/src/core/task-evaluation.ts
+var digestBytes = (value) => createHash7("sha256").update(value).digest("hex");
+var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path11.sep}`);
+var relative = (root, candidate) => path11.relative(root, candidate).split(path11.sep).join("/") || ".";
+var canonicalPath = (value) => {
+  if (typeof value !== "string" || !value)
+    return null;
+  if (value.includes("\\") || value.split("/").includes(".."))
+    return null;
+  const normalized = path11.posix.normalize(value);
+  if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
+    return null;
+  return normalized === "." ? "." : normalized.replace(/\/$/, "");
+};
+var canonicalScope = (scope) => {
+  const paths = scope.paths.length ? scope.paths : ["."];
+  const normalizedPaths = paths.map(canonicalPath);
+  const normalizedExclusions = scope.exclusions.map(canonicalPath);
+  if (normalizedPaths.some((value) => value === null) || normalizedExclusions.some((value) => value === null))
+    return null;
+  return {
+    description: scope.description,
+    paths: [...new Set(normalizedPaths)],
+    exclusions: [...new Set(normalizedExclusions)]
+  };
+};
+var excluded = (value, exclusions) => exclusions.some((item) => item === value || item !== "." && value.startsWith(`${item}/`));
+var scopeMatches = (value, scope) => {
+  const normalized = canonicalScope(scope);
+  if (!normalized)
+    return false;
+  const paths = normalized.paths;
+  return paths.some((item) => item === "." || value === item || value.startsWith(`${item}/`)) && !excluded(value, normalized.exclusions);
+};
+var pathRelevant = (value, scope) => scopeMatches(value, scope);
+var compareCodeUnits2 = (left, right) => {
+  const length = Math.min(left.length, right.length);
+  for (let index = 0;index < length; index += 1) {
+    const difference = left.charCodeAt(index) - right.charCodeAt(index);
+    if (difference !== 0)
+      return difference;
+  }
+  return left.length - right.length;
+};
+var gitPaths = (root) => {
+  const result = spawnSync6("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+    cwd: root,
+    encoding: "buffer"
+  });
+  if (result.status !== 0) {
+    const stderr = result.stderr?.toString("utf8") ?? "";
+    return {
+      paths: [],
+      uncertain: !/not a git repository/i.test(stderr),
+      git: !/not a git repository/i.test(stderr)
+    };
+  }
+  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path11.sep).join("/")) : [];
+  const stagedDeleted = spawnSync6("git", ["diff", "--cached", "--name-only", "--diff-filter=D", "-z"], { cwd: root, encoding: "buffer" });
+  if (stagedDeleted.status !== 0) {
+    const stderr = stagedDeleted.stderr?.toString("utf8") ?? "";
+    if (!/not a git repository/i.test(stderr))
+      return { paths, uncertain: true, git: true };
+  } else if (stagedDeleted.stdout) {
+    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path11.sep).join("/")));
+  }
+  return { paths: [...new Set(paths)], uncertain: false, git: true };
+};
+var walk = (root, directory, output) => {
+  let names;
+  try {
+    names = fs11.readdirSync(directory);
+  } catch {
+    return true;
+  }
+  let uncertain = false;
+  for (const name of names) {
+    if (name === ".git" || name === ".workit")
+      continue;
+    const target = path11.join(directory, name);
+    let stat;
+    try {
+      stat = fs11.lstatSync(target);
+    } catch {
+      uncertain = true;
+      continue;
+    }
+    const item = relative(root, target);
+    output.add(item);
+    if (stat.isDirectory() && !stat.isSymbolicLink())
+      uncertain = walk(root, target, output) || uncertain;
+  }
+  return uncertain;
+};
+var scopeRoots = (root, scope) => {
+  const roots = [];
+  for (const item of scope.paths.length ? scope.paths : ["."]) {
+    const target = path11.resolve(root, item);
+    if (!inside(root, target))
+      return failure2("invalid_input", `candidate scope escapes checkout: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} is outside the checkout` }] });
+    let ancestor = target;
+    while (!fs11.existsSync(ancestor) && ancestor !== root)
+      ancestor = path11.dirname(ancestor);
+    try {
+      if (!inside(root, fs11.realpathSync(ancestor)))
+        return failure2("invalid_input", `candidate scope escapes checkout through a symlink: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} resolves outside the checkout` }] });
+    } catch {
+      return failure2("invalid_input", `candidate scope cannot be inspected: ${item}`);
+    }
+    roots.push(target);
+  }
+  return success(null, null, roots);
+};
+function captureCandidate(root, scope, environment = []) {
+  let checkout;
   try {
-    checkout = fs10.realpathSync(root);
+    checkout = fs11.realpathSync(root);
   } catch {
     return failure2("invalid_input", "candidate root does not exist");
   }
@@ -12293,11 +13164,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;
@@ -12313,17 +13184,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()) {
@@ -12348,7 +13219,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;
@@ -12488,7 +13359,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");
   }
@@ -12497,23 +13368,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: [
               {
@@ -12529,7 +13400,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");
@@ -12614,7 +13485,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 {
@@ -12869,10 +13768,10 @@ Autonomy contract:
   inferred, or guess. Prose is a note: only a configured check the CLI ran
   (\`workit check <name>\`) satisfies a gate; an ad-hoc
   \`workit check -- <cmd>\` never does.
-- Author is not verifier: never record a passing verdict on work your session
-  wrote. The lead starts each verifier with its own session
-  (\`WORKIT_SESSION_ID=<lead>-v<n>\`; Claude Code subagents get one from the
-  hook), and the verifier records \`workit ledger verdict\`.
+- Author is not verifier: your own verdict is \`--self\` (after an observed
+  \`workit check test\`), shown as self-reviewed, never verified. High risk,
+  \`verification: independent\` and merge need a verifier with its own
+  session (\`WORKIT_SESSION_ID=<lead>-v<n>\`; Claude Code subagents get one).
 - A local-commit endpoint does not imply PR readiness, and a local commit alone
   is not evidence of a requested remote push. Before reporting delivery,
   reconcile every requested item and observe it (\`workit verify-delivery\`).
@@ -12885,7 +13784,9 @@ PATH, \`npx -y @brainervirus/workit-cli\`). \`busy\` is retryable
 The task families (task, policy, evidence, finding, decision, worker, state)
 are optional continuity for tracked work; each branch has one implicit task
 that the first recording creates, and a solo edit needs no task. A decision
-records a user choice; it never authorizes an effect.
+records a user choice; it never authorizes an effect. Judge work once with
+\`workit policy assess --judge risk= behavior= product-choice= plan=\`; an
+open choice or missing plan blocks edits until recorded.
 Omit revisions; a revision_conflict means one you passed is stale, so re-read.
 Across repositories, bind each item to its checkout, branch and endpoint,
 resolve competing targets before a mutation, and reconcile an uncertain
@@ -13023,7 +13924,7 @@ var exportDigest = (bundle) => sha256({
   task: bundle.task
 });
 // packages/workit-core/src/core/branch.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 
 // packages/workit-core/src/core/git.ts
 import { execFileSync } from "node:child_process";
@@ -13097,14 +13998,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
 var EVENT = {
@@ -13148,7 +14049,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()) => {
@@ -13158,12 +14059,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;
   }
@@ -13171,9 +14072,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())
@@ -13244,7 +14145,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 = () => {
@@ -13253,6 +14154,8 @@ var readConfig = () => {
     throw new Error(result.error);
   return result.config ?? DEFAULTS;
 };
+var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path12.join(configDir(), "vcs.json");
+var branchGlobPattern = (glob) => new RegExp(`^${glob.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`, "i");
 var resolveBranchPolicy = (config, workspace) => {
   const wp = workspace?.branchPolicy ?? {};
   const preset = Object.hasOwn(PRESETS, wp.preset) ? wp.preset : config.branchPolicy?.preset ?? "gitflow";
@@ -13260,7 +14163,7 @@ var resolveBranchPolicy = (config, workspace) => {
     allowed: wp.allowed,
     protectedNames: wp.protected
   }, config);
-  const allowed = merged.allowed.map((p) => new RegExp(`^${p.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`, "i"));
+  const allowed = merged.allowed.map(branchGlobPattern);
   return {
     preset,
     allowed,
@@ -13289,8 +14192,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");
@@ -13324,26 +14228,31 @@ var versionSourceSchema = discriminatedUnion("kind", [
   object({ kind: literal("manual") }).strict()
 ]);
 var releaseTrackSchema = object({
-  strategy: branchPreset,
+  strategy: branchPreset.optional(),
   productionBranch: nonBlank,
   integrationBranch: nonBlank,
-  naming: object({ feature: nonBlank, release: nonBlank, hotfix: nonBlank }).strict(),
-  baseBranch: nonBlank,
-  mergeBackBranches: array(nonBlank),
-  pullRequestTarget: nonBlank,
-  tagNamespace: string2(),
-  versionSource: versionSourceSchema,
-  requiredChecks: array(nonBlank)
-}).strict().superRefine((track, context) => {
+  naming: object({
+    feature: nonBlank.optional(),
+    release: nonBlank.optional(),
+    hotfix: nonBlank.optional()
+  }).passthrough().optional(),
+  baseBranch: nonBlank.optional(),
+  mergeBackBranches: array(nonBlank).optional(),
+  pullRequestTarget: nonBlank.optional(),
+  tagNamespace: string2().optional(),
+  versionSource: versionSourceSchema.optional(),
+  requiredChecks: array(nonBlank).optional(),
+  critical: array(nonBlank).optional()
+}).passthrough().superRefine((track, context) => {
   for (const [field, values] of [
-    ["mergeBackBranches", track.mergeBackBranches],
-    ["requiredChecks", track.requiredChecks]
+    ["mergeBackBranches", track.mergeBackBranches ?? []],
+    ["requiredChecks", track.requiredChecks ?? []]
   ]) {
     if (new Set(values).size !== values.length) {
       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"],
@@ -13362,6 +14271,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()
@@ -13402,6 +14312,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++) {
@@ -13499,6 +14475,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({
@@ -13520,8 +14520,8 @@ var resolveRuntimeWorkspaceVcs = (cwd) => resolveRuntimeWorkspaceCandidate(cwd,
 var runtimeWorkspaceIndexSchema = object({
   workspaces: array(object({ name: nonBlank, glob: nonBlank }).passthrough()).optional()
 }).passthrough();
-var resolveRuntimeWorkspaceCandidate = (cwd, kind) => {
-  const file = path11.join(configDir(), "workspaces.json");
+var matchRuntimeWorkspace = (cwd) => {
+  const file = path13.join(configDir(), "workspaces.json");
   let raw;
   try {
     raw = readFileSync4(file, "utf8");
@@ -13555,8 +14555,17 @@ var resolveRuntimeWorkspaceCandidate = (cwd, kind) => {
   });
   const workspaceName = process.env.WORKFLOW_WORKSPACE_NAME?.trim() || undefined;
   const selected = selectWorkspaceMatch(matches, cwd, workspaceName);
-  if (!selected)
+  return selected ? { file, selected } : null;
+};
+var resolveRuntimeReleaseTracks = (cwd) => {
+  const matched = matchRuntimeWorkspace(cwd);
+  return matched ? { workspace: matched.selected.name, releaseTracks: matched.selected.releaseTracks } : null;
+};
+var resolveRuntimeWorkspaceCandidate = (cwd, kind) => {
+  const matched = matchRuntimeWorkspace(cwd);
+  if (!matched)
     return null;
+  const { file, selected } = matched;
   const policy = runtimeWorkspacePolicySchema(kind).safeParse(selected);
   if (!policy.success) {
     const detail = policy.error.issues.map((issue) => `${issue.path.map(String).join(".") || "workspace"}: ${issue.message}`).join("; ");
@@ -13581,16 +14590,424 @@ var resolveRuntimeWorkspacePolicy = (cwd, kind, requestedProfile) => {
     policy: profilePolicy ?? workspacePolicy,
     source: profilePolicy ? `profile:${profileName}` : workspacePolicy ? `workspace:${candidate.name}` : "user-default"
   };
-};
+};
+function workspaceDefaultTarget(cwd, globalDefault) {
+  const ws = resolveRuntimeWorkspaceVcs(cwd);
+  const wp = ws?.branchPolicy ?? {};
+  const hasWorkspacePolicy = typeof wp.preset === "string" && Object.hasOwn(PRESETS, wp.preset);
+  const selected = resolveRuntimeWorkspacePolicy(cwd, "branch", process.env.WORKFLOW_PROFILE?.trim() || undefined);
+  const policyDefault = resolveBranchPolicy(readConfig(), selected.policy ? { branchPolicy: selected.policy } : null).defaultTargetBranch;
+  return String(ws?.vcs?.defaultTargetBranch ?? (hasWorkspacePolicy ? policyDefault : globalDefault ?? policyDefault) ?? "develop");
+}
+
+// packages/workit-core/src/core/vcs-config.ts
+import fs12 from "node:fs";
+import path14 from "node:path";
+import { spawnSync as spawnSync8 } from "node:child_process";
+
+// packages/workit-core/src/core/release-tracks.ts
+import { createHash as createHash9 } from "node:crypto";
+import { spawnSync as spawnSync7 } from "node:child_process";
+class ReleaseTrackError extends Error {
+}
+var KNOWN_FIELDS = new Set([
+  "strategy",
+  "productionBranch",
+  "integrationBranch",
+  "naming",
+  "baseBranch",
+  "mergeBackBranches",
+  "pullRequestTarget",
+  "tagNamespace",
+  "versionSource",
+  "requiredChecks",
+  "critical"
+]);
+var BRANCH_FIELDS = ["productionBranch", "integrationBranch", "baseBranch", "pullRequestTarget"];
+var PLACEHOLDER = /\{[^}]*\}/gu;
+var HAS_PLACEHOLDER = /\{[^}]*\}/u;
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var branchName = (value) => typeof value === "string" && value.trim() && !value.trim().startsWith("-") ? value.trim() : null;
+var namedBranches = (entry) => [
+  ...BRANCH_FIELDS.map((field) => branchName(entry[field])),
+  ...Array.isArray(entry.mergeBackBranches) ? entry.mergeBackBranches.map(branchName) : []
+].filter((name) => name !== null);
+var literalOf = (template) => template.replace(PLACEHOLDER, "").replace(/[*/]/gu, "").trim();
+function readReleaseTracks(raw) {
+  const out = { tracks: [], issues: [], error: null, protectedBranches: [] };
+  if (raw === undefined || raw === null)
+    return out;
+  if (!isRecord3(raw)) {
+    out.issues.push("releaseTracks is not an object; ignored");
+    return out;
+  }
+  const fatal = [];
+  const protectedNames = new Set;
+  for (const [name, entry] of Object.entries(raw).toSorted(([a], [b]) => a < b ? -1 : 1)) {
+    const label = `release track ${JSON.stringify(name)}`;
+    if (!isRecord3(entry)) {
+      out.issues.push(`${label} is not an object; ignored`);
+      continue;
+    }
+    for (const branch of namedBranches(entry))
+      protectedNames.add(branch);
+    if (!name.trim()) {
+      out.issues.push("a release track with a blank name was ignored");
+      continue;
+    }
+    let critical = [];
+    if (Array.isArray(entry.critical))
+      critical = entry.critical.filter((item) => typeof item === "string");
+    else if (entry.critical !== undefined)
+      out.issues.push(`${label} critical: must be a list of field names; ignored`);
+    const isCritical = (field) => critical.some((item) => field === item || field.startsWith(`${item}.`));
+    const problem = (field, message) => {
+      if (isCritical(field))
+        fatal.push(`${label} ${field}: ${message}`);
+      else
+        out.issues.push(`${label} ${field}: ${message}`);
+    };
+    for (const key of Object.keys(entry))
+      if (!KNOWN_FIELDS.has(key))
+        problem(key, "unknown field, ignored");
+    const productionBranch = branchName(entry.productionBranch);
+    const integrationBranch = branchName(entry.integrationBranch);
+    if (!productionBranch)
+      problem("productionBranch", "missing or not a branch name");
+    if (!integrationBranch)
+      problem("integrationBranch", "missing or not a branch name");
+    const optionalBranch = (field) => {
+      if (entry[field] === undefined)
+        return null;
+      const value = branchName(entry[field]);
+      if (!value)
+        problem(field, "not a branch name; using the integration branch");
+      return value;
+    };
+    const baseBranch = optionalBranch("baseBranch");
+    const pullRequestTarget = optionalBranch("pullRequestTarget");
+    let mergeBackBranches = [];
+    if (entry.mergeBackBranches !== undefined) {
+      const list = Array.isArray(entry.mergeBackBranches) ? entry.mergeBackBranches.map(branchName) : [null];
+      if (list.some((item) => item === null))
+        problem("mergeBackBranches", "must be a list of branch names; ignored");
+      else
+        mergeBackBranches = [...new Set(list)];
+    }
+    const naming = {};
+    if (entry.naming !== undefined) {
+      if (!isRecord3(entry.naming))
+        problem("naming", "not an object; ignored");
+      else
+        for (const kind of ["feature", "release", "hotfix"]) {
+          const template = entry.naming[kind];
+          if (template === undefined)
+            continue;
+          if (typeof template !== "string" || !template.trim())
+            problem(`naming.${kind}`, "not a template string; ignored");
+          else if (!literalOf(template))
+            problem(`naming.${kind}`, "needs literal text besides placeholders; ignored");
+          else
+            naming[kind] = template.trim();
+        }
+    }
+    if (!productionBranch || !integrationBranch) {
+      out.issues.push(`${label} was skipped: it needs a productionBranch and integrationBranch`);
+      continue;
+    }
+    out.tracks.push({
+      name,
+      productionBranch,
+      integrationBranch,
+      baseBranch: baseBranch ?? integrationBranch,
+      pullRequestTarget: pullRequestTarget ?? integrationBranch,
+      mergeBackBranches,
+      naming
+    });
+  }
+  out.protectedBranches = [...protectedNames];
+  if (fatal.length)
+    out.error = `workspace releaseTracks cannot be read by this Workit (${fatal.join("; ")}); upgrade Workit or fix the track`;
+  return out;
+}
+var trackBranches = (tracks) => [
+  ...new Set(tracks.flatMap((track) => [
+    track.productionBranch,
+    track.integrationBranch,
+    track.baseBranch,
+    track.pullRequestTarget,
+    ...track.mergeBackBranches
+  ]))
+];
+var namingGlob = (template) => HAS_PLACEHOLDER.test(template) ? template.replace(PLACEHOLDER, "*") : `${template.replace(/\/?\*?$/u, "")}/*`;
+var IMPLICIT = "";
+var ownedBy = (tracks, branch) => tracks.filter((track) => [track.integrationBranch, track.productionBranch, track.baseBranch].includes(branch));
+var shortRef = (ref, remotes) => {
+  const bare = ref.replace(/^refs\/heads\//u, "").replace(/^refs\/remotes\/[^/]+\//u, "");
+  const remote = remotes.find((name) => bare.startsWith(`${name}/`));
+  return remote ? bare.slice(remote.length + 1) : bare;
+};
+var MAX_RECORDED_HOPS = 10;
+function resolveReleaseTrack(input) {
+  const tracks = [...input.tracks];
+  const issues = [...input.issues ?? []];
+  const requested = input.requested?.trim();
+  if (tracks.length === 0) {
+    if (requested)
+      return {
+        status: "invalid",
+        error: `no release tracks configured for this workspace; --track ${requested} cannot apply`,
+        issues
+      };
+    return { status: "none", issues };
+  }
+  const names = tracks.map((track) => track.name).join(", ");
+  let envProblem = null;
+  const done = (track, source, detail, warnings = [], ambiguous = null) => ({
+    status: "resolved",
+    track: track && track.name !== IMPLICIT ? track : null,
+    source,
+    detail,
+    warnings: [...issues, ...envProblem ? [envProblem] : [], ...warnings],
+    tracks,
+    blocking: envProblem ?? ambiguous
+  });
+  if (requested) {
+    const named = tracks.find((track) => track.name === requested);
+    if (!named)
+      return {
+        status: "invalid",
+        error: `no release track ${JSON.stringify(requested)}; configured: ${names}`,
+        issues
+      };
+    return done(named, "flag", `track ${named.name} was requested explicitly`);
+  }
+  const owned = (branch) => branch !== null && tracks.some((track) => [
+    track.integrationBranch,
+    track.productionBranch,
+    track.baseBranch,
+    track.pullRequestTarget
+  ].includes(branch));
+  const implicit = input.defaultBranch && !owned(input.defaultBranch) ? {
+    name: IMPLICIT,
+    productionBranch: input.defaultBranch,
+    integrationBranch: input.defaultBranch,
+    baseBranch: input.defaultBranch,
+    pullRequestTarget: input.defaultBranch,
+    mergeBackBranches: [],
+    naming: {}
+  } : null;
+  const candidates = implicit ? [...tracks, implicit] : tracks;
+  const label = (track) => track.name === IMPLICIT ? `the workspace default line (${track.integrationBranch})` : `track ${track.name}`;
+  const fallback = (why) => {
+    const byDefault = input.defaultBranch ? tracks.filter((track) => track.integrationBranch === input.defaultBranch || track.pullRequestTarget === input.defaultBranch) : [];
+    const track = byDefault.length === 1 ? byDefault[0] : null;
+    const target = track ? `track ${track.name}` : `default target ${input.defaultBranch ?? "(none)"}`;
+    const ambiguous = candidates.length >= 2 ? `can't tell which release line ${input.branch ?? "HEAD"} is on (${why}); pass --track <name> (${names}) or --base <branch>` : null;
+    return done(track, "default", `${why}; using the workspace ${target}`, [
+      `release track not determined: ${why}; using the workspace ${target} (pass --track <name> to choose)`
+    ], ambiguous);
+  };
+  const branch = input.branch;
+  if (branch) {
+    const owners = ownedBy(candidates, branch);
+    if (owners.length === 1)
+      return done(owners[0], "branch", `${branch} is a branch of ${label(owners[0])}`);
+    if (owners.length > 1)
+      return fallback(`${branch} belongs to more than one track (${owners.map((track) => track.name).join(", ")})`);
+  }
+  const env = input.envRequested?.trim();
+  if (env) {
+    const named = tracks.find((track) => track.name === env);
+    if (named)
+      return done(named, "env", `WORKFLOW_RELEASE_TRACK selects track ${named.name}`);
+    envProblem = `WORKFLOW_RELEASE_TRACK=${env} names no release track of this workspace (${names}); ignored`;
+  }
+  if (!branch)
+    return fallback("HEAD is detached");
+  if (tracks.length === 1 && !implicit)
+    return done(tracks[0], "only-track", `${tracks[0].name} is the only track`);
+  let remotes = null;
+  const short = (ref) => shortRef(ref, remotes ??= input.probe.remotes());
+  const ownerOf = (ref) => {
+    const owner = ownedBy(candidates, short(ref));
+    return owner.length === 1 ? owner[0] : null;
+  };
+  const followRecorded = (start) => {
+    let cursor = start;
+    const seen = new Set([start]);
+    for (let hop = 0;hop < MAX_RECORDED_HOPS; hop += 1) {
+      const recorded = input.probe.recordedBase(cursor);
+      if (!recorded)
+        return null;
+      const base = short(recorded);
+      const owner = ownerOf(base);
+      if (owner)
+        return owner;
+      if (ownedBy(candidates, base).length > 1 || seen.has(base))
+        return null;
+      seen.add(base);
+      cursor = base;
+    }
+    return null;
+  };
+  const recordedOwner = followRecorded(branch);
+  if (recordedOwner)
+    return done(recordedOwner, "recorded-base", `${branch} was created on ${label(recordedOwner)}'s line (recorded base)`);
+  for (const source of ["reflog", "checkout"]) {
+    const ref = source === "reflog" ? input.probe.createdFrom(branch) : input.probe.checkedOutFrom(branch);
+    if (!ref)
+      continue;
+    const owner = ownerOf(ref) ?? followRecorded(short(ref));
+    if (owner)
+      return done(owner, source, `${branch} was created from ${short(ref)} (${source === "reflog" ? "branch reflog" : "HEAD reflog"})`);
+  }
+  const forks = [];
+  for (const track of candidates)
+    for (const ref of new Set([track.integrationBranch, track.baseBranch])) {
+      const sha = input.probe.mergeBase(branch, ref);
+      if (sha)
+        forks.push({ track, ref, sha });
+    }
+  if (forks.length === 0)
+    return fallback(`no track branch could be compared with ${branch} (fetch the track branches)`);
+  const ancestry = new Map;
+  const descends = (older, newer) => {
+    if (older === newer)
+      return false;
+    const key = `${older}>${newer}`;
+    if (!ancestry.has(key))
+      ancestry.set(key, input.probe.isAncestor(older, newer));
+    return ancestry.get(key);
+  };
+  const winners = forks.filter((fork) => forks.every((other) => other.track === fork.track || descends(other.sha, fork.sha)));
+  const winningTracks = [...new Set(winners.map((fork) => fork.track))];
+  if (winningTracks.length === 1 && forks.some((fork) => fork.track !== winningTracks[0])) {
+    const win = winners[0];
+    return done(win.track, "ancestry", `${branch} forked from ${win.ref} at ${win.sha.slice(0, 12)}, after every other line's fork point`);
+  }
+  if (winningTracks.length === 1)
+    return fallback(`only ${label(winningTracks[0])} could be compared with ${branch}`);
+  const newest = forks.filter((fork) => !forks.some((other) => descends(fork.sha, other.sha)));
+  return fallback(`${branch} has the same or unrelated fork points with ${[...new Set(newest.map((fork) => `${fork.ref} (${fork.track.name === IMPLICIT ? "workspace default" : fork.track.name})`))].join(" and ")}`);
+}
+var git4 = (cwd, args) => {
+  const run = spawnSync7("git", args, {
+    cwd,
+    encoding: "utf8",
+    timeout: 20000,
+    windowsHide: true,
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  return run.status === 0 ? (run.stdout ?? "").trim() : null;
+};
+var recordedBaseKey = (branch) => `branch.${branch}.workitBase`;
+var escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+var reflog = (cwd, ref) => (git4(cwd, ["log", "-g", "--date=unix", "--format=%H%x09%gd%x09%gs", ref, "--"]) ?? "").split(`
+`).map((line) => {
+  const [sha = "", selector = "", ...subject] = line.split("\t");
+  return {
+    sha,
+    time: Number(/@\{(\d+)\}$/u.exec(selector)?.[1] ?? Number.NaN),
+    subject: subject.join("\t")
+  };
+}).filter((entry) => entry.sha && Number.isFinite(entry.time));
+function gitTrackProbe(cwd) {
+  let remote;
+  let remotes;
+  const tip = (branch) => {
+    remote ??= pushRemoteName(cwd) ?? "origin";
+    return resolveRef(cwd, `refs/remotes/${remote}/${branch}`) ?? resolveRef(cwd, `refs/heads/${branch}`);
+  };
+  return {
+    remotes: () => remotes ??= remoteNames(cwd),
+    recordedBase: (branch) => git4(cwd, ["config", "--get", recordedBaseKey(branch)]) || null,
+    createdFrom: (branch) => {
+      const log = git4(cwd, ["reflog", "show", "--format=%gs", `refs/heads/${branch}`, "--"]);
+      const oldest = log?.split(`
+`).findLast(Boolean) ?? "";
+      const match = /^branch: Created from (\S+)$/u.exec(oldest);
+      return match && match[1] !== "HEAD" ? match[1] : null;
+    },
+    checkedOutFrom: (branch) => {
+      const own = reflog(cwd, `refs/heads/${branch}`);
+      const created = own.at(-1);
+      if (!created || created.subject !== "branch: Created from HEAD")
+        return null;
+      const pattern = new RegExp(`^checkout: moving from (\\S+) to ${escapeRegExp(branch)}$`, "u");
+      const entry = reflog(cwd, "HEAD").findLast((item) => item.time >= created.time && item.sha === created.sha && pattern.test(item.subject));
+      return entry ? pattern.exec(entry.subject)?.[1] ?? null : null;
+    },
+    mergeBase: (branch, trackBranch) => {
+      const base = tip(trackBranch);
+      return base && resolveRef(cwd, `refs/heads/${branch}`) ? mergeBase(cwd, base, `refs/heads/${branch}`) : null;
+    },
+    isAncestor: (ancestor, descendant) => git4(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]) !== null
+  };
+}
+function workspaceReleaseTracks(cwd) {
+  const raw = resolveRuntimeReleaseTracks(cwd);
+  return { workspace: raw?.workspace ?? null, ...readReleaseTracks(raw?.releaseTracks) };
+}
+var memo3 = new Map;
+var MEMO_LIMIT = 64;
+function resolveTrackFor(cwd, options) {
+  const read = workspaceReleaseTracks(cwd);
+  if (read.error)
+    return { status: "invalid", error: read.error, issues: read.issues };
+  if (read.tracks.length === 0 && !options.track?.trim())
+    return { status: "none", issues: read.issues };
+  const branch = options.branch === undefined ? currentBranch(cwd) : options.branch;
+  const envRequested = process.env.WORKFLOW_RELEASE_TRACK?.trim() || null;
+  const input = {
+    tracks: read.tracks,
+    requested: options.track ?? null,
+    envRequested,
+    branch,
+    defaultBranch: options.defaultBranch,
+    issues: read.issues
+  };
+  let key = null;
+  if (!options.probe) {
+    const refs = git4(cwd, [
+      "for-each-ref",
+      "--format=%(refname) %(objectname)",
+      "refs/heads",
+      "refs/remotes"
+    ]) ?? "";
+    const head = git4(cwd, ["reflog", "show", "-n", "1", "--format=%H %gs", "HEAD", "--"]) ?? "";
+    const own = branch ? [
+      git4(cwd, [
+        "log",
+        "-g",
+        "-n",
+        "1",
+        "--date=unix",
+        "--format=%H %gd %gs",
+        `refs/heads/${branch}`,
+        "--"
+      ]) ?? "",
+      git4(cwd, ["config", "--get", recordedBaseKey(branch)]) ?? ""
+    ] : [];
+    key = createHash9("sha256").update(JSON.stringify({ cwd, input, refs, head, own })).digest("hex");
+    const hit = memo3.get(key);
+    if (hit)
+      return hit;
+  }
+  const resolution = resolveReleaseTrack({ ...input, probe: options.probe ?? gitTrackProbe(cwd) });
+  if (key) {
+    if (memo3.size >= MEMO_LIMIT)
+      memo3.delete(memo3.keys().next().value);
+    memo3.set(key, resolution);
+  }
+  return resolution;
+}
 
 // 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");
+var workspacesPath = () => path14.join(configDir(), "workspaces.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 = spawnSync8("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
   if (r.status !== 0)
     return null;
   const url = (r.stdout ?? "").trim();
@@ -13627,7 +15044,7 @@ var remoteEndpoint = (remote) => {
 var configuredSshEndpoint = (host) => {
   if (host.startsWith("-"))
     return null;
-  const resolved = spawnSync6("ssh", ["-G", host], {
+  const resolved = spawnSync8("ssh", ["-G", host], {
     encoding: "utf8",
     timeout: 5000,
     maxBuffer: 1024 * 1024,
@@ -13677,7 +15094,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: {} };
   }
@@ -13692,7 +15109,16 @@ var readVcsConfig = () => {
   }
   return { status: "malformed", path: file, config: {}, error: `${file} is not a JSON object` };
 };
-function vcsConfig(mode, cwd) {
+var trackSummary = (resolution) => resolution.status === "resolved" ? {
+  name: resolution.track?.name ?? null,
+  source: resolution.source,
+  detail: resolution.detail,
+  warnings: resolution.warnings,
+  track: resolution.track,
+  tracks: resolution.tracks,
+  blocking: resolution.blocking
+} : null;
+function vcsConfig(mode, cwd, options = {}) {
   const ws = resolveRuntimeWorkspaceVcs(vcsCwd(cwd));
   const wsVcs = ws?.vcs ?? {};
   const wsYt = ws?.youtrack ?? {};
@@ -13702,10 +15128,7 @@ function vcsConfig(mode, cwd) {
   const determinateRoot = cwd !== undefined || process.env.WORKFLOW_WORKSPACE_ROOT !== undefined;
   const rawProvider = wsVcs.provider ?? (determinateRoot ? remoteProvider(root) : null) ?? cfg.provider ?? null;
   const provider = rawProvider === null || rawProvider === undefined ? null : String(rawProvider).toLowerCase() || null;
-  const wp = ws?.branchPolicy ?? {};
-  const hasWorkspacePolicy = typeof wp.preset === "string" && Object.hasOwn(PRESETS, wp.preset);
-  const policyDefault = resolveBranchPolicyFor(root).defaultTargetBranch;
-  const defaultTarget = String(wsVcs.defaultTargetBranch ?? (hasWorkspacePolicy ? policyDefault : cfg.defaultTargetBranch ?? policyDefault) ?? "develop");
+  const workspaceDefault = workspaceDefaultTarget(root, cfg.defaultTargetBranch);
   const linkIssues = typeof wsYt.link_issues === "boolean" ? wsYt.link_issues : null;
   const youtrackBaseUrl = typeof wsYt.baseUrl === "string" ? wsYt.baseUrl : null;
   let issuesProvider = null;
@@ -13717,11 +15140,24 @@ function vcsConfig(mode, cwd) {
   if (mode === "resolve") {
     if (cfgStatus === "malformed")
       return { ok: false, error: cfgError, configPath: cfgPath };
+    const trackResolution = resolveTrackFor(root, {
+      track: options.track,
+      ...options.branch !== undefined ? { branch: options.branch } : {},
+      defaultBranch: workspaceDefault
+    });
+    if (trackResolution.status === "invalid")
+      return { ok: false, error: trackResolution.error, configPath: workspacesPath() };
+    const releaseTrack = trackSummary(trackResolution);
+    const defaultTarget = releaseTrack?.track?.pullRequestTarget ?? workspaceDefault;
+    const baseBranch = releaseTrack?.track?.baseBranch ?? defaultTarget;
     return {
       ok: true,
       workspace_name: ws?.name ?? null,
       provider,
       defaultTargetBranch: defaultTarget,
+      workspaceDefaultTargetBranch: workspaceDefault,
+      baseBranch,
+      releaseTrack,
       link_issues: linkIssues,
       youtrack_base_url: youtrackBaseUrl,
       issues_provider: issuesProvider,
@@ -13743,9 +15179,9 @@ function vcsConfig(mode, cwd) {
   const prov = cfg[provider] ?? {};
   const out = {
     ok: true,
-    configPath: path12.resolve(cfgPath),
+    configPath: path14.resolve(cfgPath),
     provider,
-    defaultTargetBranch: defaultTarget,
+    defaultTargetBranch: workspaceDefault,
     pr: cfg.pr ?? {},
     workspace_name: ws?.name ?? null,
     link_issues: linkIssues,
@@ -13781,7 +15217,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 = spawnSync8("git", ["remote", "get-url", "--push", "--all", "origin"], {
     cwd,
     encoding: "utf8"
   });
@@ -13797,7 +15233,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) => spawnSync8("glab", ["api", ...args], {
       cwd,
       encoding: "utf8",
       env
@@ -13817,7 +15253,7 @@ function mergedPrStyle(limit = 6, cwd) {
       });
     }
   } else if (provider === "github") {
-    const r = spawnSync6("gh", [
+    const r = spawnSync8("gh", [
       "pr",
       "list",
       "--repo",
@@ -13850,11 +15286,35 @@ function mergedPrStyle(limit = 6, cwd) {
 }
 
 // packages/workit-core/src/core/branch.ts
+var withReleaseTracks = (workspaceRoot, policy) => {
+  const read = workspaceReleaseTracks(workspaceRoot);
+  if (read.error)
+    throw new ReleaseTrackError(read.error);
+  if (read.tracks.length === 0 && read.protectedBranches.length === 0)
+    return policy;
+  const known = new Set(policy.allowed.map((pattern) => pattern.source));
+  const allowed = [...policy.allowed];
+  for (const glob of read.tracks.flatMap((track) => Object.values(track.naming).map(namingGlob))) {
+    const pattern = branchGlobPattern(glob);
+    if (!known.has(pattern.source)) {
+      known.add(pattern.source);
+      allowed.push(pattern);
+    }
+  }
+  return {
+    ...policy,
+    allowed,
+    protected: new Set([
+      ...policy.protected,
+      ...[...trackBranches(read.tracks), ...read.protectedBranches].map((name) => name.toLowerCase())
+    ])
+  };
+};
 function effectiveWorkspacePolicy(workspaceRoot, kind, profileName) {
   const selected = resolveRuntimeWorkspacePolicy(workspaceRoot, kind, profileName?.trim() || process.env.WORKFLOW_PROFILE?.trim() || undefined);
   const config = readConfig();
   return kind === "branch" ? {
-    branchPolicy: resolveBranchPolicy(config, selected.policy ? { branchPolicy: selected.policy } : null),
+    branchPolicy: withReleaseTracks(workspaceRoot, resolveBranchPolicy(config, selected.policy ? { branchPolicy: selected.policy } : null)),
     provenance: { branchPolicy: selected.source }
   } : {
     commitPolicy: resolveCommitPolicy(config, selected.policy ? { commitPolicy: selected.policy } : null),
@@ -13893,7 +15353,7 @@ var branchPolicySnapshotFor = (workspaceRoot) => {
   const source = resolved.provenance.branchPolicy;
   const allowed = branchPolicy.allowed.map((pattern) => `${pattern.source}/${pattern.flags}`).toSorted();
   const protectedRefs = [...branchPolicy.protected].map((name) => name.toLowerCase()).toSorted();
-  const fingerprint = createHash7("sha256").update(JSON.stringify({ allowed, protectedRefs, source })).digest("hex");
+  const fingerprint = createHash10("sha256").update(JSON.stringify({ allowed, protectedRefs, source })).digest("hex");
   return {
     branchPolicy,
     namePolicy: { allowed: branchPolicy.allowed, protected: branchPolicy.protected },
@@ -13917,7 +15377,6 @@ var validateBranchNameFor = (workspaceRoot, name) => {
     };
   }
 };
-var resolveBranchPolicyFor = (workspaceRoot, profileName) => effectiveWorkspacePolicy(workspaceRoot, "branch", profileName).branchPolicy;
 
 // packages/workit-core/src/core/route-intent.ts
 var shellBranchTarget = (command) => {
@@ -13938,305 +15397,34 @@ var shellBranchPolicyViolation = (root, command) => {
 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");
@@ -14264,7 +15452,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,
@@ -14457,22 +15860,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,
@@ -14484,18 +15872,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;
 };
@@ -14512,6 +15888,7 @@ var importedTask = (source, bundle, destinationWorkspaceId, context, timestamp)
   for (const entry of [
     source.intent,
     ...source.assessments,
+    ...source.judgments ?? [],
     ...source.evidence,
     ...source.decisions,
     ...source.findings,
@@ -14535,9 +15912,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),
@@ -14605,6 +15989,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);
@@ -14674,7 +16059,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;
@@ -14928,7 +16314,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")
@@ -14939,16 +16329,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
       };
@@ -15150,9 +16541,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) ?? []);
@@ -15160,7 +16556,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
@@ -15519,16 +16915,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) {
@@ -15854,9 +17246,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 spawnSync9 } 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);
@@ -15883,7 +17275,7 @@ var invalidRange = (cwd) => ({
   cwd
 });
 var runGit = (cwd, args) => {
-  const result = spawnSync7("git", args, { cwd, encoding: "utf8" });
+  const result = spawnSync9("git", args, { cwd, encoding: "utf8" });
   return {
     stdout: (result.stdout ?? "").trimEnd(),
     stderr: (result.stderr ?? "").trimEnd(),
@@ -15894,11 +17286,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",
@@ -15912,11 +17304,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,
@@ -15990,7 +17382,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("/");
@@ -16021,8 +17413,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"));
@@ -16047,9 +17439,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("\\", "/"));
       }
     }
   };
@@ -16057,7 +17449,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(`
 `);
@@ -16065,7 +17457,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 = "";
@@ -16081,7 +17473,7 @@ function prReadyContext(root, range) {
   stdout += printSection("Repository");
   stdout += `root: ${cwd}
 `;
-  stdout += `branch: ${currentBranch(cwd)}
+  stdout += `branch: ${currentBranch2(cwd)}
 `;
   stdout += `range: ${range}
 `;
@@ -16123,7 +17515,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
 
@@ -16133,7 +17525,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"]);
@@ -16142,7 +17534,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.
 `;
   }
@@ -16175,7 +17567,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);
@@ -16185,7 +17577,7 @@ function changelogContext(root, range) {
   stdout += printSection("Repository");
   stdout += `root: ${cwd}
 `;
-  stdout += `branch: ${currentBranch(cwd)}
+  stdout += `branch: ${currentBranch2(cwd)}
 `;
   stdout += `range: ${resolvedRange}
 `;
@@ -16193,8 +17585,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 {
@@ -16213,7 +17605,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);
@@ -16223,7 +17615,7 @@ function docsRefreshContext(root, range) {
   stdout += printSection("Repository");
   stdout += `root: ${cwd}
 `;
-  stdout += `branch: ${currentBranch(cwd)}
+  stdout += `branch: ${currentBranch2(cwd)}
 `;
   stdout += `range: ${resolvedRange}
 `;
@@ -16235,8 +17627,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 {
@@ -16244,8 +17636,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) + `
@@ -16258,7 +17650,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 };
@@ -16272,7 +17664,7 @@ function releaseNotesContext(root, rangeOrTag) {
   stdout += printSection("Repository");
   stdout += `root: ${cwd}
 `;
-  stdout += `branch: ${currentBranch(cwd)}
+  stdout += `branch: ${currentBranch2(cwd)}
 `;
   stdout += `requested: ${rangeOrTag}
 `;
@@ -16296,7 +17688,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 + `
 `;
   }
@@ -16324,12 +17716,12 @@ function releaseNotesContext(root, rangeOrTag) {
 }
 
 // packages/workit-core/src/core/tracker-issues.ts
-import { spawnSync as spawnSync9 } from "node:child_process";
+import { spawnSync as spawnSync11 } 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 spawnSync10 } from "node:child_process";
 // packages/workit-core/src/forge/pr-body.ts
 function parseGhIssue(value) {
   const m = /issues\/(\d+)/.exec(value);
@@ -16339,13 +17731,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 {}
     }
@@ -16354,7 +17746,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 = spawnSync10("git", ["remote", "get-url", "--push", "--all", "origin"], {
     cwd,
     encoding: "utf8"
   });
@@ -16385,7 +17777,7 @@ var defaultCli = (bin, available) => {
   if (!available)
     return null;
   return (args, root) => {
-    const out = spawnSync9(bin, args, {
+    const out = spawnSync11(bin, args, {
       cwd: root,
       encoding: "utf8",
       env: { ...process.env, PATH: process.env.PATH ?? "" }
@@ -16463,8 +17855,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();
@@ -16477,22 +17869,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 };
   }
@@ -16503,11 +17895,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" };
   }
@@ -16546,12 +17938,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)) {
@@ -16616,9 +18008,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];
@@ -16903,22 +18295,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 = spawnSync12(executable, args, {
     cwd,
     encoding: "utf8",
     env: { ...process.env, ...env }
@@ -16955,7 +18347,7 @@ var capabilitiesFor = (descriptor, observed = {}) => descriptor.capabilities.map
   };
 });
 // packages/workit-core/src/hooks/context.ts
-import path17 from "node:path";
+import path20 from "node:path";
 var MIGRATION_PENDING_NOTE = "workit migration pending — run `workit task status`";
 var migrationPending = (result) => !result.ok && result.code === "needs_input" && (result.error ?? "").startsWith(MIGRATION_PENDING);
 var boundTo = (entry, session) => entry.sessions.some((item) => item.host === session.host && item.handle === session.handle);
@@ -17034,7 +18426,7 @@ function entryCompactContext(store, entry, session, context) {
     return null;
   const freshness = { mode: "signal", current: () => recentSignal(store.root) };
   const observed = task.data.evidence.some(isObservedCheck);
-  const files = task.data.decisions.flatMap((decision) => decision.data.binding.contentRefs.flatMap((ref) => ref.kind === "file" ? [path17.resolve(store.root, ref.path)] : []));
+  const files = task.data.decisions.flatMap((decision) => decision.data.binding.contentRefs.flatMap((ref) => ref.kind === "file" ? [path20.resolve(store.root, ref.path)] : []));
   const observedFiles = filesKey(files);
   const compact = new WorkitCore(store, context).compactContext(entry.id, freshness);
   if (!compact.ok)
@@ -17051,17 +18443,424 @@ function entryCompactContext(store, entry, session, context) {
     cache.delete(cache.keys().next().value);
   return compact.data;
 }
+var utcNow = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+var hookOperationContext = (input, descriptor) => ({
+  root: input.cwd,
+  caller: { host: input.host, actor: input.session.id },
+  callerAttested: false,
+  capabilities: capabilitiesFor(descriptor, { "session.start": true }),
+  constraints: [],
+  now: utcNow
+});
+var sessionContextText = (input, descriptor, options) => {
+  const session = { host: input.host, handle: input.session.id };
+  let compact = "";
+  let offer = null;
+  try {
+    const store = new TaskStore(input.cwd);
+    const listed = store.listTaskIndex();
+    if (migrationPending(listed))
+      return `<workit-contract>
+${invariantBootstrap()}
+${MIGRATION_PENDING_NOTE}${options.addendum ? `
+${options.addendum}` : ""}
+</workit-contract>`;
+    if (!listed.ok)
+      throw new Error(listed.error);
+    const entry = currentTaskEntry(listed.data, session, descriptor.context.task) ?? implicitTaskEntry(store, listed.data, session);
+    const text = entry ? entryCompactContext(store, entry, session, hookOperationContext(input, descriptor)) : null;
+    if (text)
+      compact = `
+<workit-task-context>${text}</workit-task-context>`;
+    if (options.offer)
+      offer = unfinishedTaskOffer(listed.data, session, entry?.id ?? null);
+  } catch {
+    compact = `
+[workit diagnostic: task state unavailable]`;
+  }
+  return `<workit-contract>
+${invariantBootstrap()}${compact}${offer ? `
+${offer}` : ""}${options.addendum ? `
+${options.addendum}` : ""}
+</workit-contract>`;
+};
+var turnContextText = (input, descriptor) => {
+  try {
+    const text = sessionCompactContext(new TaskStore(input.cwd), { host: input.host, handle: input.session.id }, hookOperationContext(input, descriptor), descriptor.context.task);
+    if (text === MIGRATION_PENDING_NOTE)
+      return text;
+    return text ? `<workit-task-context>${text}</workit-task-context>` : null;
+  } catch {
+    return null;
+  }
+};
 // packages/workit-core/src/hooks/policy.ts
 var shellPolicy = (cwd, command) => {
   const policy = shellBranchPolicyViolation(cwd, command);
   return policy && !policy.ok ? { kind: "deny", reason: `branch_policy_denied: ${policy.error}`, unblock: null } : { kind: "none" };
 };
+// packages/workit-core/src/hooks/write-gate.ts
+import { realpathSync as realpathSync6 } from "node:fs";
+import path21 from "node:path";
+var NONE2 = { kind: "none" };
+var CASE_INSENSITIVE = process.platform === "darwin" || process.platform === "win32";
+var canonical2 = (file) => {
+  let rest = "";
+  for (let dir = path21.resolve(file);; dir = path21.dirname(dir)) {
+    try {
+      return path21.join(realpathSync6(dir), rest);
+    } catch {
+      if (path21.dirname(dir) === dir)
+        return path21.resolve(file);
+      rest = rest ? path21.join(path21.basename(dir), rest) : path21.basename(dir);
+    }
+  }
+};
+var exempt = (cwd, root, file, plans) => {
+  const fold = (value) => CASE_INSENSITIVE ? value.toLowerCase() : value;
+  const relative = path21.relative(fold(canonical2(root)), fold(canonical2(path21.resolve(cwd, file))));
+  if (relative.startsWith("..") || path21.isAbsolute(relative))
+    return true;
+  const posix = relative.split(path21.sep).join("/");
+  const segments = posix.split("/");
+  return /\.mdx?$/i.test(posix) || segments[0] === "docs" || segments.includes("plans") || [...plans].some((plan) => fold(plan) === posix);
+};
+var segmentsOf = (command) => {
+  const segments = [];
+  let current = { words: [], redirects: [] };
+  let word = "";
+  let inWord = false;
+  let pending = null;
+  const heredocs = [];
+  const flushWord = () => {
+    if (!inWord)
+      return;
+    if (pending === "redirect") {
+      if (!word.startsWith("&"))
+        current.redirects.push(word);
+    } else if (pending === "heredoc")
+      heredocs.push(word.replace(/^-/, ""));
+    else if (pending !== "input")
+      current.words.push(word);
+    pending = null;
+    word = "";
+    inWord = false;
+  };
+  const flushSegment = () => {
+    flushWord();
+    if (current.words.length || current.redirects.length)
+      segments.push(current);
+    current = { words: [], redirects: [] };
+  };
+  for (let index = 0;index < command.length; index++) {
+    const char = command[index];
+    if (char === "'" || char === '"') {
+      const end = command.indexOf(char, index + 1);
+      word += command.slice(index + 1, end < 0 ? undefined : end);
+      inWord = true;
+      index = end < 0 ? command.length : end;
+    } else if (char === "\\" && index + 1 < command.length) {
+      word += command[++index];
+      inWord = true;
+    } else if (char === `
+`) {
+      flushSegment();
+      while (heredocs.length) {
+        const delimiter = heredocs.shift();
+        const lines = command.slice(index + 1).split(`
+`);
+        const at = lines.findIndex((line) => line.trim() === delimiter);
+        const skipped = (at < 0 ? lines : lines.slice(0, at + 1)).join(`
+`).length + 1;
+        index += skipped;
+      }
+    } else if (/\s/.test(char))
+      flushWord();
+    else if (";&|()".includes(char)) {
+      if (char === "&" && command[index + 1] === ">")
+        continue;
+      flushSegment();
+    } else if (char === ">") {
+      if (inWord && /^\d$/.test(word)) {
+        word = "";
+        inWord = false;
+      } else
+        flushWord();
+      if (command[index + 1] === ">")
+        index++;
+      if (command[index + 1] === "&") {
+        index++;
+        word = "&";
+        inWord = true;
+      }
+      pending = "redirect";
+    } else if (char === "<") {
+      flushWord();
+      if (command[index + 1] === "<") {
+        index++;
+        if (command[index + 1] === "<")
+          index++;
+        pending = "heredoc";
+      } else
+        pending = "input";
+    } else {
+      word += char;
+      inWord = true;
+    }
+  }
+  flushSegment();
+  return segments;
+};
+var PREFIXES = new Set(["sudo", "command", "env", "nohup", "time", "exec", "xargs"]);
+var operands = (words) => words.filter((item) => !item.startsWith("-"));
+var editsOf = (input) => {
+  let words = input;
+  while (words.length && (PREFIXES.has(words[0]) || /^\w+=/.test(words[0])))
+    words = words.slice(1);
+  const [verb, ...args] = words;
+  const name = (verb?.split(/[\\/]/).at(-1) ?? "").toLowerCase();
+  if (!name || name === "workit" || name === "npx" && args.some((item) => /workit/.test(item)))
+    return [];
+  switch (name) {
+    case "touch":
+    case "mkdir":
+    case "rm":
+    case "rmdir":
+    case "tee":
+    case "mv":
+    case "truncate":
+      return operands(args);
+    case "cp":
+    case "ln":
+    case "install": {
+      const target = args.indexOf("-t");
+      if (target >= 0)
+        return args[target + 1] ? [args[target + 1]] : null;
+      const last = operands(args).at(-1);
+      return last ? [last] : null;
+    }
+    case "dd":
+      return args.filter((item) => item.startsWith("of=")).map((item) => item.slice(3));
+    case "sed":
+    case "perl": {
+      if (!args.some((item) => /^-[a-zA-Z]*i|^--in-place/.test(item)))
+        return [];
+      const scripted = args.some((item) => item === "-e" || item === "-f");
+      const files = [];
+      for (let index = 0;index < args.length; index++) {
+        if (args[index] === "-e" || args[index] === "-f")
+          index++;
+        else if (!args[index].startsWith("-"))
+          files.push(args[index]);
+      }
+      return scripted ? files : files.slice(1);
+    }
+    case "patch":
+      return null;
+    case "set-content":
+    case "add-content":
+    case "out-file":
+    case "new-item":
+    case "ni":
+    case "remove-item":
+    case "del":
+    case "copy-item":
+    case "move-item": {
+      const flag = args.findIndex((item) => /^-(?:path|filepath|literalpath|destination)$/i.test(item));
+      if (flag >= 0)
+        return args[flag + 1] ? [args[flag + 1]] : null;
+      const files = operands(args);
+      if (name === "move-item")
+        return files.length ? files : null;
+      const file = name === "copy-item" ? files.at(-1) : files[0];
+      return file ? [file] : null;
+    }
+    case "git": {
+      const sub = operands(args)[0];
+      if (sub === "apply")
+        return null;
+      if (sub === "restore" || sub === "mv" || sub === "rm")
+        return operands(args).slice(1);
+      if (sub === "checkout" && args.includes("--"))
+        return args.slice(args.indexOf("--") + 1);
+      return [];
+    }
+    default:
+      return [];
+  }
+};
+var shellWrites = (command) => {
+  const targets = [];
+  let unknown = false;
+  for (const segment of segmentsOf(command)) {
+    targets.push(...segment.redirects.filter((item) => !/^\/dev\/(?:null|stdout|stderr|tty)$/.test(item)));
+    const edits = editsOf(segment.words);
+    if (edits === null)
+      unknown = true;
+    else
+      targets.push(...edits);
+  }
+  if (!unknown && targets.length === 0)
+    return { writes: false, targets: null };
+  return { writes: true, targets: unknown ? null : targets };
+};
+var cache2 = new Map;
+var planKeyOf = (root, plans) => [...plans].map((file) => fileSignature(path21.resolve(root, file)) ?? "-").join("\x00");
+var gateFor = (cwd) => {
+  const store = new TaskStore(cwd);
+  const listed = store.listTaskIndex();
+  if (!listed.ok)
+    return null;
+  const key = store.currentKey();
+  if (!key.ok)
+    return null;
+  const entry = listed.data.filter((item) => item.key === key.data.key && item.status !== "closed").toSorted((left, right) => right.updatedAt.localeCompare(left.updatedAt))[0];
+  if (!entry)
+    return { blockers: [], root: store.root, plans: new Set };
+  const ledger = ledgerPath(store.root);
+  const cacheKey = `${entry.id}\x00${entry.revision}\x00${ledger.ok && fileSignature(ledger.value) || "-"}`;
+  const hit = cache2.get(store.root);
+  if (hit && hit.key === cacheKey && hit.planKey === planKeyOf(store.root, hit.plans))
+    return hit;
+  const task = store.readTask(entry.id);
+  if (!task.ok)
+    return null;
+  const workspace = store.readWorkspace();
+  const plans = new Set((latestJudgment(task.data)?.refs ?? []).flatMap((ref) => ref.kind === "file" ? [ref.path] : []));
+  const blockers = writeBlockers(task.data, store.root).filter((blocker) => {
+    const requirement = task.data.policy?.requirements.find((item) => item.ruleId === blocker.ruleId && item.before === "write");
+    return !(requirement?.acceptanceAllowed && workspace.ok && workspace.data && applicableDecision(task.data, workspace.data, requirement, store.root).length > 0);
+  });
+  const gate = {
+    blockers,
+    root: store.root,
+    plans,
+    key: cacheKey,
+    planKey: planKeyOf(store.root, plans)
+  };
+  cache2.set(store.root, gate);
+  if (cache2.size > 32)
+    cache2.delete(cache2.keys().next().value);
+  return gate;
+};
+function writeGate(cwd, paths) {
+  try {
+    const gate = gateFor(cwd);
+    if (!gate || gate.blockers.length === 0)
+      return NONE2;
+    if (paths && paths.every((file) => exempt(cwd, gate.root, file, gate.plans)))
+      return NONE2;
+    const reasons = gate.blockers.map((item) => `${item.ruleId}: ${item.reason}`).join("; ");
+    return {
+      kind: "deny",
+      reason: `workit before-write gate: ${reasons}. Markdown, docs/, plans/ and files outside the checkout stay writable.`,
+      unblock: gate.blockers[0].reason
+    };
+  } catch {
+    return NONE2;
+  }
+}
+// packages/workit-core/src/hooks/hosts/fields.ts
+var isRecord4 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var nonEmpty2 = (value) => typeof value === "string" && value.trim() !== "";
+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"
+]);
+var PATH_KEYS = ["file_path", "filePath", "notebook_path", "path", "target_file", "file"];
+var writePaths = (input) => {
+  if (!isRecord4(input))
+    return [];
+  const paths = PATH_KEYS.map((key) => input[key]).filter(nonEmpty2);
+  for (const value of Object.values(input))
+    if (typeof value === "string")
+      for (const match of value.matchAll(/^\*\*\* (?:Add|Update|Delete) File: (.+)$/gm))
+        paths.push(match[1].trim());
+  return [...new Set(paths)];
+};
 // packages/workit-core/src/hooks/handle.ts
+var usable2 = (value) => value === "native" || value === "partial";
+var NONE3 = { kind: "none" };
 var offered = new Set;
+var CLAUDE_WORKTREE_IMPLEMENTER = "workit:implementer";
 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"]);
-
+var subagentSession = (session, agentId) => [session, agentId].filter((part) => Boolean(part)).join(":").replace(/[^A-Za-z0-9_.:@/+-]/g, "-").slice(0, 128);
+var subagentStartText = (host, session, descriptor, event) => {
+  if (host === "claude_code" && event.agentType === CLAUDE_WORKTREE_IMPLEMENTER)
+    return `Workit observed ${descriptor.label} subagent ${event.agentId} (${event.agentType}) working in its own git worktree: it may edit and commit there, within its brief's scope. Before the first commit, switch to a policy-compliant branch with \`workit git branch <branch> --base <base>\` (e.g. feature/<slug>); branch policy hooks still deny protected or non-compliant branches. Never record a verdict on your own work. Never push, open a PR, or merge unless the brief asks for it.`;
+  const readOnly = `Workit observed ${descriptor.label} subagent ${event.agentId} (${event.agentType}) as read-only/agent-guided.`;
+  if (host === "claude_code" && event.agentType && CLAUDE_JUDGES.has(event.agentType) && event.agentId)
+    return `${readOnly} Its own Workit session is ${subagentSession(session, event.agentId)}: record verdicts with \`workit ledger verdict <result> --session ${subagentSession(session, event.agentId)} ...\` so the ledger tells it apart from the author.`;
+  return readOnly;
+};
+function handleHook(input, deps) {
+  const { descriptor } = deps;
+  const event = input.event;
+  switch (event.kind) {
+    case "session.start": {
+      if (!usable2(descriptor.context.sessionStart))
+        return NONE3;
+      const key = input.session.id ? `${input.host}\x00${input.session.id}` : null;
+      const offer = event.source === "startup" && (key === null || !offered.has(key));
+      if (offer && key !== null)
+        offered.add(key);
+      const advisory = usable2(descriptor.events["write.pre"].support) ? null : `Workit cannot gate file writes on ${descriptor.label} (no pre-write hook): before-write requirements (an open product choice, a missing plan) are advisory here, so settle them before editing.`;
+      const addendum = [deps.addendum, advisory].filter(Boolean).join(`
+`) || null;
+      return {
+        kind: "context",
+        text: sessionContextText(input, descriptor, { offer, addendum })
+      };
+    }
+    case "context.turn": {
+      if (!usable2(descriptor.context.perTurn))
+        return NONE3;
+      const text = turnContextText(input, descriptor);
+      return text ? { kind: "context", text } : NONE3;
+    }
+    case "shell.pre": {
+      const policy = usable2(descriptor.shellPolicy.deny) ? shellPolicy(input.cwd, event.command) : NONE3;
+      if (policy.kind !== "none" || !usable2(descriptor.events["write.pre"].support))
+        return policy;
+      const writes = shellWrites(event.command);
+      return writes.writes ? writeGate(input.cwd, writes.targets) : NONE3;
+    }
+    case "write.pre":
+      return usable2(descriptor.events["write.pre"].support) ? writeGate(input.cwd, event.paths) : NONE3;
+    case "subagent.start":
+      return {
+        kind: "context",
+        text: subagentStartText(input.host, input.session.id ?? null, descriptor, event)
+      };
+    case "compact.pre":
+      return {
+        kind: "notice",
+        userMessage: "Workit context may be stale after compaction; re-run inspection or resume before acting."
+      };
+    case "tool.pre":
+    case "shell.post":
+    case "subagent.stop":
+    case "prompt.submit":
+    case "stop":
+      return NONE3;
+  }
+}
 // 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"]);
@@ -17088,6 +18887,7 @@ var PI_DESCRIPTOR = {
     "context.turn": { support: "native", native: "before_agent_start" },
     "shell.pre": { support: "native", native: "tool_call" },
     "tool.pre": { support: "native", native: "tool_call" },
+    "write.pre": { support: "native", native: "tool_call" },
     "shell.post": { support: "native", native: "tool_result" },
     "subagent.start": { support: "none", native: null },
     "subagent.stop": { support: "none", native: null },
@@ -17206,7 +19006,7 @@ var output = (result) => ({
   content: [{ type: "text", text: JSON.stringify(result) }],
   details: result
 });
-var schemaFor = (family) => ({ type: "object", ...boundedOperationJsonSchema(family, OPERATION_SCHEMA_DEPTH, true) });
+var schemaFor = (family) => flatOperationJsonSchema(family, { stringTolerant: true });
 var decodeStrings = (value) => {
   if (typeof value === "string") {
     try {
@@ -17228,10 +19028,9 @@ var trustedForMutation = (ctx, action) => {
   return failure2("permission_denied", "Pi project is not trusted for Workit mutations");
 };
 var executeFamily = async (family, input, ctx) => {
-  const parsedStrict = parseOperation(family, input);
-  const parsed = parsedStrict.ok ? parsedStrict : parseOperation(family, decodeStrings(input));
+  const parsed = parseAdvertisedOperation(family, input, "pi");
   if (!parsed.ok)
-    return output(parsedStrict);
+    return output(parsed);
   const trust = trustedForMutation(ctx, parsed.data.action);
   if (!trust.ok)
     return output(trust);
@@ -17244,7 +19043,7 @@ var registerWorkitTools = (pi, options = {}) => {
     pi.registerTool({
       name: `workit_${family}`,
       label: `workit_${family}`,
-      description: `Workit ${family} operations backed by the shared task contract.`,
+      description: operationDescription(family),
       parameters: schemaFor(family),
       async execute(_toolCallId, input, _signal, _onUpdate, ctx) {
         return executeFamily(family, input, ctx);
@@ -17266,27 +19065,42 @@ var registerWorkitTools = (pi, options = {}) => {
   });
 };
 var enforceToolPolicy = (event, ctx) => {
+  const gate = (hookEvent) => {
+    const decision = handleHook({
+      host: "pi",
+      cwd: ctx.cwd,
+      session: { id: "", agentId: null, agentType: null, parentId: null },
+      permissionMode: null,
+      transcriptPath: null,
+      event: hookEvent
+    }, { descriptor: PI_DESCRIPTOR, addendum: null });
+    return decision.kind === "deny" ? { block: true, reason: decision.reason } : undefined;
+  };
   if (event.toolName === "bash") {
     const command = event.input?.command;
-    const decision = typeof command === "string" ? shellPolicy(ctx.cwd, command) : null;
-    return decision?.kind === "deny" ? { block: true, reason: decision.reason } : undefined;
+    return typeof command === "string" ? gate({ kind: "shell.pre", command, toolUseId: null }) : undefined;
   }
   if (event.toolName !== "write" && event.toolName !== "edit")
     return;
   if (!ctx.isProjectTrusted())
     return { block: true, reason: "Pi project is not trusted" };
-  return;
+  return gate({
+    kind: "write.pre",
+    tool: event.toolName,
+    paths: writePaths(event.input),
+    toolUseId: null
+  });
 };
 
 // packages/workit-pi/src/launches.ts
 import { mkdirSync as mkdirSync3, readFileSync as readFileSync6, readdirSync as readdirSync5, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
-import os3 from "node:os";
-import path18 from "node:path";
+import os4 from "node:os";
+import path22 from "node:path";
 var launchDir = (root) => {
   const location = resolveStore(root);
-  return location instanceof Error ? null : path18.join(location.dir, "pi-launches");
+  return location instanceof Error ? null : path22.join(location.dir, "pi-launches");
 };
-var fileFor = (dir, workerId) => path18.join(dir, `${workerId.replace(/[^A-Za-z0-9-]/g, "_")}.json`);
+var fileFor = (dir, workerId) => path22.join(dir, `${workerId.replace(/[^A-Za-z0-9-]/g, "_")}.json`);
 var recordLaunch = (root, attempt) => {
   const dir = launchDir(root);
   if (!dir)
@@ -17296,7 +19110,7 @@ var recordLaunch = (root, attempt) => {
     writeFileSync3(fileFor(dir, attempt.workerId), JSON.stringify({
       ...attempt,
       pid: process.pid,
-      host: os3.hostname(),
+      host: os4.hostname(),
       at: new Date().toISOString()
     }), { flag: "wx" });
     return true;
@@ -17310,7 +19124,7 @@ var clearLaunch = (root, workerId) => {
     rmSync2(fileFor(dir, workerId), { force: true });
 };
 var alive = (attempt) => {
-  if (attempt.host !== os3.hostname())
+  if (attempt.host !== os4.hostname())
     return true;
   try {
     process.kill(attempt.pid, 0);
@@ -17332,7 +19146,7 @@ var abandonedLaunches = (root) => {
   const found = [];
   for (const name of names) {
     try {
-      const attempt = JSON.parse(readFileSync6(path18.join(dir, name), "utf8"));
+      const attempt = JSON.parse(readFileSync6(path22.join(dir, name), "utf8"));
       if (typeof attempt.workerId === "string" && typeof attempt.session === "string") {
         if (!alive(attempt))
           found.push(attempt);
@@ -17350,9 +19164,9 @@ import { randomUUID as randomUUID4 } from "node:crypto";
 // packages/workit-pi/src/worker-protocol.ts
 var MAX_WORKER_LINE_BYTES = 64 * 1024;
 var MAX_WORKER_STDERR_BYTES = 64 * 1024;
-var isRecord3 = (value) => typeof value === "object" && value !== null;
+var isRecord5 = (value) => typeof value === "object" && value !== null;
 var parseEvent2 = (value) => {
-  if (!isRecord3(value) || typeof value.type !== "string")
+  if (!isRecord5(value) || typeof value.type !== "string")
     return null;
   if (value.type === "workit_worker_ready") {
     if (typeof value.workerId !== "string" || typeof value.sessionId !== "string")