@attalabs/vinaya 0.28.0 → 0.29.0

package/dist/checks/bin/check-exec-bits.js

@@ -3,8 +3,8 @@ import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/checks/bin/check-exec-bits.ts
-import { execFileSync as execFileSync6 } from "node:child_process";
-import { readFileSync as readFileSync3 } from "node:fs";
+import { execFileSync as execFileSync7 } from "node:child_process";
+import { readFileSync as readFileSync4 } from "node:fs";
 
 // src/checks/contract.ts
 var CHECK_SCHEMA_VERSION = 1;
@@ -14,8 +14,8 @@ function emitCheckError(error) {
 }
 
 // src/lib/diff-evidence.ts
-import { execFileSync as execFileSync5 } from "node:child_process";
-import { join as join4, relative, resolve as resolve2 } from "node:path";
+import { execFileSync as execFileSync6 } from "node:child_process";
+import { join as join5, relative, resolve as resolve2 } from "node:path";
 // ../../packages/aeg-core/src/gate-audience.ts
 var GATE_AUDIENCE = {
   "check-branch-topology": { shippedAs: "branch-topology", ring: 0 },
@@ -1656,6 +1656,52 @@ var systemEnv3 = {
   ...process.env,
   PATH: [process.env.PATH, "/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"].filter(Boolean).join(":")
 };
+var defaultExec = () => execFileAsync3("git", ["remote", "get-url", "origin"], { env: systemEnv3, timeout: 5000 });
+var cached;
+var inflight;
+async function resolveRepo(exec = defaultExec) {
+  if (cached !== undefined)
+    return cached;
+  const fromEnv = process.env.AEG_REPO;
+  if (fromEnv) {
+    const parsed = parseOwnerRepo(fromEnv);
+    if (parsed) {
+      cached = parsed;
+      return cached;
+    }
+  }
+  if (inflight)
+    return inflight;
+  inflight = (async () => {
+    try {
+      const { stdout } = await exec();
+      cached = parseGitRemoteUrl(stdout.trim());
+      return cached;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.warn(`[aeg-forge-state] resolveRepo: git remote lookup failed (will retry): ${message}`);
+      return null;
+    } finally {
+      inflight = undefined;
+    }
+  })();
+  return inflight;
+}
+function parseGitRemoteUrl(url) {
+  const ssh = url.match(/^git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/);
+  if (ssh?.[1] && ssh[2])
+    return { owner: ssh[1], repo: ssh[2] };
+  const https = url.match(/^https?:\/\/(?:[^@]+@)?github\.com\/([^/]+)\/(.+?)(?:\.git)?\/?$/);
+  if (https?.[1] && https[2])
+    return { owner: https[1], repo: https[2] };
+  return null;
+}
+function parseOwnerRepo(value) {
+  const match = value.match(/^([^/]+)\/(.+)$/);
+  if (!match?.[1] || !match[2])
+    return null;
+  return { owner: match[1], repo: match[2] };
+}
 // ../../packages/aeg-core/src/anchored-region.ts
 function anchoredRegionBounds(body, field) {
   const masked = maskCode(body);
@@ -1968,6 +2014,7 @@ var OBJECTIVES_VERSION_PATTERN = /^[ \t]*(?:\*{1,3}|_{1,3})?Objectives version:\
 var RULING_ORDINAL_PATTERN = /^[ \t]*(?:\*{1,3}|_{1,3})?Ruling ordinal:\s*(\d+)(?!\d)/im;
 var BRIEF_HASH_PATTERN = /^[ \t]*(?:\*{1,3}|_{1,3})?Brief hash:\s*([0-9a-f]{64})(?![A-Za-z0-9])/im;
 var POLICY_DIGEST_PATTERN = /^[ \t]*(?:\*{1,3}|_{1,3})?Policy digest:\s*([0-9a-f]{64})(?![A-Za-z0-9])/im;
+var BASE_SHA_PATTERN = /^[ \t]*(?:\*{1,3}|_{1,3})?Judged base:\s*([0-9a-f]{7,40})(?![A-Za-z0-9])/im;
 function firstFiveLines(comment) {
   return comment.split(`
 `).slice(0, 5).join(`
@@ -2003,6 +2050,15 @@ function extractPolicyDigest(comment) {
   const m = firstElevenLines(comment).match(POLICY_DIGEST_PATTERN);
   return m ? m[1].toLowerCase() : null;
 }
+function firstThirteenLines(comment) {
+  return comment.split(`
+`).slice(0, 13).join(`
+`);
+}
+function extractBaseSha(comment) {
+  const m = firstThirteenLines(comment).match(BASE_SHA_PATTERN);
+  return m ? m[1].toLowerCase() : null;
+}
 var FINDING_SEVERITY_LINE = /^\d+\.\s+\[([A-Z][A-Z]*)\]\s+(.+?)\s+—/gm;
 function extractFindingSeverities(comment) {
   return [...comment.matchAll(FINDING_SEVERITY_LINE)].map((m) => ({
@@ -2020,6 +2076,7 @@ function extractVerdict(comments, valuePattern, missingLabel) {
       rulingOrdinal: null,
       briefHash: null,
       policyDigest: null,
+      baseSha: null,
       findingSeverities: [],
       danglingNote: `no ${missingLabel} verdict comment found on this PR`
     };
@@ -2034,6 +2091,7 @@ function extractVerdict(comments, valuePattern, missingLabel) {
       rulingOrdinal: null,
       briefHash: null,
       policyDigest: null,
+      baseSha: null,
       findingSeverities: [],
       danglingNote: `the most recent ${missingLabel} verdict comment carries a VERDICT-shaped line outside the first-five-line read window`
     };
@@ -2045,6 +2103,7 @@ function extractVerdict(comments, valuePattern, missingLabel) {
     rulingOrdinal: extractRulingOrdinal(latest),
     briefHash: extractBriefHash(latest),
     policyDigest: extractPolicyDigest(latest),
+    baseSha: extractBaseSha(latest),
     findingSeverities: extractFindingSeverities(latest),
     danglingNote: null
   };
@@ -3958,7 +4017,11 @@ function briefHash(brief) {
 `).digest("hex");
 }
 function policyDigest(policy) {
-  return createHash4("sha256").update(JSON.stringify({ codeReviewThreshold: policy.codeReviewThreshold, securityThreshold: policy.securityThreshold })).digest("hex");
+  return createHash4("sha256").update(JSON.stringify({
+    codeReviewThreshold: policy.codeReviewThreshold,
+    securityThreshold: policy.securityThreshold,
+    maxRounds: policy.maxRounds
+  })).digest("hex");
 }
 function isBoundToHead(echoed, headSha) {
   if (!echoed.headSha)
@@ -3974,8 +4037,12 @@ function isBoundByPatchIdentity(echoed, headSha, patchIdOf) {
     return false;
   return judged === current;
 }
-function isBoundToPatch(echoed, headSha, patchIdOf) {
-  return isBoundToHead(echoed, headSha) || isBoundByPatchIdentity(echoed, headSha, patchIdOf);
+function isBoundToBase(echoed, currentBase) {
+  if (currentBase === null)
+    return true;
+  if (!echoed.baseSha)
+    return false;
+  return currentBase.toLowerCase().startsWith(echoed.baseSha.toLowerCase());
 }
 function isBoundToObjectives(echoed, currentVersion) {
   if (currentVersion === null)
@@ -3996,14 +4063,18 @@ function isBoundToPolicy(echoed, currentDigest) {
   return echoed.policyDigest === currentDigest;
 }
 function compareManifest(echoed, current, patchIdOf) {
-  const head = isBoundToPatch(echoed, current.headSha, patchIdOf);
+  const exactHead = isBoundToHead(echoed, current.headSha);
+  const patchHead = exactHead ? false : isBoundByPatchIdentity(echoed, current.headSha, patchIdOf);
+  const head = exactHead || patchHead;
+  const base = patchHead ? true : isBoundToBase(echoed, current.baseSha);
   const briefHashBound = isBoundToBriefHash(echoed, current.briefHash);
   const objectivesVersion2 = isBoundToObjectives(echoed, current.objectivesVersion);
   const rulingOrdinal = isBoundToRulings(echoed, current.rulingOrdinal);
   const policyDigestBound = isBoundToPolicy(echoed, current.policyDigest);
   return {
-    bound: head && briefHashBound && objectivesVersion2 && rulingOrdinal && policyDigestBound,
+    bound: head && base && briefHashBound && objectivesVersion2 && rulingOrdinal && policyDigestBound,
     head,
+    base,
     briefHash: briefHashBound,
     objectivesVersion: objectivesVersion2,
     rulingOrdinal,
@@ -4055,6 +4126,7 @@ function checkReviewGate(input) {
   const securityClean = securityTextClean && securityPolicyClean;
   const currentManifest = {
     headSha: input.headSha,
+    baseSha: input.baseSha ?? null,
     briefHash: input.briefHash ?? null,
     objectivesVersion: input.objectivesVersion,
     rulingOrdinal: input.rulingOrdinal,
@@ -4062,6 +4134,7 @@ function checkReviewGate(input) {
   };
   const codeReviewEchoed = {
     headSha: codeReview.headSha,
+    baseSha: codeReview.baseSha,
     briefHash: codeReview.briefHash,
     objectivesVersion: codeReview.objectivesVersion,
     rulingOrdinal: codeReview.rulingOrdinal,
@@ -4069,6 +4142,7 @@ function checkReviewGate(input) {
   };
   const securityEchoed = {
     headSha: security.headSha,
+    baseSha: security.baseSha,
     briefHash: security.briefHash,
     objectivesVersion: security.objectivesVersion,
     rulingOrdinal: security.rulingOrdinal,
@@ -4096,6 +4170,8 @@ function checkReviewGate(input) {
     problems.push(`code-reviewer verdict says APPROVE but carries a finding (${codeReviewPolicyEvaluation.blockingFindings.map((f) => f.severity).join(", ")}) at or above this repository's code-review policy threshold (${policy.codeReviewThreshold}) — a reviewer's own APPROVE never overrides policy`);
   } else if (!codeReviewBound) {
     problems.push(`the newest code-review verdict covers ${codeReview.headSha ?? "no recorded commit"}, head is ${input.headSha}`);
+  } else if (!codeReviewBinding.base) {
+    problems.push(`the newest code-review verdict was cast against base ${codeReview.baseSha ?? "no recorded base"}, the PR's base is now ${currentManifest.baseSha ?? "unresolved"} (a base-only change under an unchanged candidate — same patch text on a new base is not automatically equivalent)`);
   } else if (!codeReviewObjectivesBound) {
     problems.push(`the newest code-review verdict was cast against objectives version ${codeReview.objectivesVersion ?? "none"}, the Issue's list is now ${input.objectivesVersion}`);
   } else if (!codeReviewRulingsBound) {
@@ -4111,6 +4187,8 @@ function checkReviewGate(input) {
     problems.push(`security-review verdict says PASS but carries a finding (${securityPolicyEvaluation.blockingFindings.map((f) => f.severity).join(", ")}) at or above this repository's security policy threshold (${policy.securityThreshold}) — a reviewer's own PASS never overrides policy`);
   } else if (!securityBound) {
     problems.push(`the newest security-review verdict covers ${security.headSha ?? "no recorded commit"}, head is ${input.headSha}`);
+  } else if (!securityBinding.base) {
+    problems.push(`the newest security-review verdict was cast against base ${security.baseSha ?? "no recorded base"}, the PR's base is now ${currentManifest.baseSha ?? "unresolved"} (a base-only change under an unchanged candidate — same patch text on a new base is not automatically equivalent)`);
   } else if (!securityObjectivesBound) {
     problems.push(`the newest security-review verdict was cast against objectives version ${security.objectivesVersion ?? "none"}, the Issue's list is now ${input.objectivesVersion}`);
   } else if (!securityRulingsBound) {
@@ -4968,8 +5046,8 @@ var TaskToolErrorSchema = z.object({
   detail: z.string().optional()
 });
 var TaskToolRefSchema = z.union([
-  z.object({ tranche: z.string().min(1), id: z.string().min(1) }),
-  z.object({ issue: z.number().int().positive() })
+  z.object({ tranche: z.string().min(1), id: z.string().min(1) }).strict(),
+  z.object({ issue: z.number().int().positive() }).strict()
 ]);
 var MAX_PAGE_LIMIT = 100;
 var PageRequestSchema = z.object({
@@ -4983,7 +5061,7 @@ var ObservedSchema = z.object({
 });
 var TaskStatusInputSchema = z.object({
   task: TaskToolRefSchema.optional()
-}).merge(PageRequestSchema);
+}).merge(PageRequestSchema).strict();
 var TaskStatusItemSchema = z.object({
   task: TaskToolRefSchema,
   issue: z.number().int().positive(),
@@ -5007,9 +5085,20 @@ var EscalationEvidenceSchema = z.object({
   reviewer: z.string().nullable(),
   security: z.string().nullable()
 });
+var EscalationRunIdentitySchema = z.object({
+  runId: z.string(),
+  pid: z.number().int().positive(),
+  host: z.string()
+});
+var EscalationInputVersionsSchema = z.object({
+  briefHash: z.string().nullable(),
+  objectivesVersion: z.string().nullable(),
+  rulingOrdinal: z.number().int().nonnegative(),
+  policyDigest: z.string()
+});
 var TaskEscalationReadInputSchema = z.object({
   task: TaskToolRefSchema
-}).merge(PageRequestSchema);
+}).merge(PageRequestSchema).strict();
 var TaskEscalationPacketSchema = z.object({
   reason: z.string(),
   detail: z.string().nullable(),
@@ -5017,7 +5106,9 @@ var TaskEscalationPacketSchema = z.object({
   evidence: EscalationEvidenceSchema.nullable(),
   attemptedRecovery: z.string(),
   requestedAuthority: RequestedAuthoritySchema,
-  permittedNextActions: z.array(z.string())
+  permittedNextActions: z.array(z.string()),
+  runIdentity: EscalationRunIdentitySchema.nullable(),
+  inputVersions: EscalationInputVersionsSchema.nullable()
 }).merge(ObservedSchema);
 var TaskEscalationReadResultSchema = z.object({
   items: z.array(TaskEscalationPacketSchema),
@@ -5026,15 +5117,48 @@ var TaskEscalationReadResultSchema = z.object({
 var TaskStartInputSchema = z.object({
   tranche: z.string().min(1),
   id: z.string().min(1)
+}).strict();
+var TaskStartResultSchema = z.object({
+  requestId: z.string().min(1),
+  run: z.object({ tranche: z.string().min(1), id: z.string().min(1) }),
+  started: z.boolean(),
+  startedAt: z.string(),
+  mode: z.literal("attended")
 });
 var TaskResumeInputSchema = z.object({
   task: TaskToolRefSchema
-});
+}).strict();
 var TaskCancelInputSchema = z.object({
   task: TaskToolRefSchema,
   reason: z.string().min(1)
+}).strict();
+var TaskResumeResultSchema = z.object({
+  task: z.number().int().positive(),
+  pr: z.number().int().positive(),
+  escalationId: z.string().min(1),
+  outcome: z.enum(["started", "already_resumed"]),
+  authenticatedBy: z.string().min(1),
+  authenticatedFrom: z.string().min(1)
+});
+var TaskCancelOutcomeSchema = z.enum(["confirmed", "pending", "uncertain"]);
+var TaskCancelResultSchema = z.object({
+  task: z.number().int().positive(),
+  pr: z.number().int().positive(),
+  escalationId: z.string().min(1),
+  outcome: TaskCancelOutcomeSchema,
+  authenticatedBy: z.string().min(1),
+  authenticatedFrom: z.string().min(1),
+  fencedEffectKeys: z.array(z.string())
 });
-var NoResultSchema = z.never();
+var TASK_TOOL_NAMES = [
+  "task_start",
+  "task_status",
+  "task_escalation_read",
+  "task_resume",
+  "task_cancel"
+];
+var OPERATOR_STATUS_FOLLOW = "task_status_follow";
+var OPERATOR_TOOL_GRANT = [...TASK_TOOL_NAMES, OPERATOR_STATUS_FOLLOW];
 // ../../packages/aeg-core/src/first-push-dispatch-gate.ts
 function parseTaskBranch(branch) {
   const m = /^task\/([^/]+)\/([^/]+)$/.exec(branch);
@@ -5257,6 +5381,9 @@ function findWorkspaceEscapes(files, knownPaths, workspaceDirs = DEFAULT_WORKSPA
   }
   return findings;
 }
+// ../../packages/aeg-core/src/log/envelope.ts
+import { createHash as createHash5 } from "node:crypto";
+
 // ../../packages/aeg-core/src/log/schema.ts
 import { z as z2 } from "zod";
 var ROLE_VALUES = [
@@ -5358,7 +5485,8 @@ var DispatchOutcomeSchema = z2.discriminatedUnion("type", [
   }).strict(),
   z2.object({ type: z2.literal("brief"), comment_id: z2.number().int(), hash: z2.string() }).strict(),
   z2.object({ type: z2.literal("plan"), issues: z2.array(z2.number().int()) }).strict(),
-  z2.object({ type: z2.literal("archive"), provenance_comment_id: z2.number().int() }).strict()
+  z2.object({ type: z2.literal("archive"), provenance_comment_id: z2.number().int() }).strict(),
+  z2.object({ type: z2.literal("completed") }).strict()
 ]);
 var dispatchShared = {
   meta: HeaderMetaSchema,
@@ -5418,7 +5546,8 @@ var DevReviewLoopEventSchema = z2.discriminatedUnion("event", [
     round: z2.number().int(),
     head: z2.string(),
     all_approve: z2.boolean(),
-    blockers: z2.number().int().nonnegative()
+    blockers: z2.number().int().nonnegative(),
+    findings: z2.array(ReviewFindingSchema).optional()
   }).strict(),
   z2.object({
     ...loopShared,
@@ -5597,7 +5726,9 @@ var roleAttemptShared = {
   kind: z2.literal("role_attempt"),
   ...envelopeTail,
   actor: z2.string().nullable(),
-  attempt: z2.number().int().nullable()
+  attempt: z2.number().int().nullable(),
+  effect_id: z2.string(),
+  model: z2.string().nullable()
 };
 var RoleAttemptEventSchema = z2.discriminatedUnion("event", [
   z2.object({
@@ -5656,6 +5787,144 @@ var LogEventSchema = z2.union([
   HandoffEventSchema,
   EffectEventSchema
 ]);
+
+// ../../packages/aeg-core/src/log/envelope.ts
+function isRole(value) {
+  return value !== undefined && ROLE_VALUES.includes(value);
+}
+function actorIdFromEnv(role) {
+  return role === undefined || role === "" ? null : role;
+}
+function lineageFieldFromEnv(value) {
+  return value === undefined || value === "" ? null : value;
+}
+function attemptFromEnv(value) {
+  if (value === undefined || value === "")
+    return null;
+  const n = Number(value);
+  return Number.isInteger(n) ? n : null;
+}
+function provenanceFor(input) {
+  if (input.provenance)
+    return input.provenance;
+  if (input.env.role || input.env.task)
+    return "env_correlated";
+  return "unavailable";
+}
+function issueFromTask(task) {
+  if (task === undefined || task === "")
+    return null;
+  const n = Number(task);
+  return Number.isInteger(n) ? n : null;
+}
+function roundFromEnv(round) {
+  if (round === undefined || round === "")
+    return;
+  const n = Number(round);
+  return Number.isInteger(n) ? n : undefined;
+}
+function buildHeader(input) {
+  const role = isRole(input.env.role) ? input.env.role : "unattributed";
+  const round = roundFromEnv(input.env.round);
+  const subject = {
+    issue: issueFromTask(input.env.task),
+    role,
+    ...round !== undefined ? { round } : {},
+    ...input.subject ?? {}
+  };
+  return {
+    meta: {
+      schema: 2,
+      ts: input.now.toISOString(),
+      run_id: input.runId,
+      seq: input.seq,
+      repo: input.repo,
+      vinaya: input.vinaya,
+      doctrine: input.doctrine,
+      host: input.host,
+      machine: createHash5("sha256").update(input.hostname).digest("hex"),
+      event_id: input.eventId,
+      process_id: input.processId,
+      actor_id: actorIdFromEnv(input.env.role),
+      lineage: {
+        run: lineageFieldFromEnv(input.env.run),
+        attempt: attemptFromEnv(input.env.attempt),
+        parent: lineageFieldFromEnv(input.env.parent)
+      },
+      input_versions: {
+        objectives_version: input.inputVersions?.objectivesVersion ?? null,
+        brief_hash: input.inputVersions?.briefHash ?? null,
+        ruling_ordinal: input.inputVersions?.rulingOrdinal ?? null,
+        policy_digest: input.inputVersions?.policyDigest ?? null
+      },
+      provenance: provenanceFor(input)
+    },
+    subject
+  };
+}
+// ../../packages/aeg-core/src/log/redact.ts
+var GITHUB_TOKEN_PATTERN = /\b(?:gho_|ghp_|ghs_|ghu_|ghr_|github_pat_)[A-Za-z0-9_]+\b/g;
+var CLASSIC_GITHUB_PAT_PATTERN = /\b((?:token|GITHUB_TOKEN|PAT|api[_-]?key|api[_-]?token)\s*[:=]\s*)[a-f0-9]{40}\b/gi;
+var BEARER_TOKEN_PATTERN = /\bBearer\s+\S+/g;
+var AWS_ACCESS_KEY_PATTERN = /\bAKIA[0-9A-Z]{16}\b/g;
+var SLACK_TOKEN_PATTERN = /\bxox[baprs]-[0-9A-Za-z-]+\b/g;
+var STRIPE_KEY_PATTERN = /\b(?:sk|pk|rk)_(?:live|test)_[0-9A-Za-z]{10,}\b/g;
+var ANTHROPIC_KEY_PATTERN = /\bsk-ant-[A-Za-z0-9_-]{20,}\b/g;
+var OPENAI_KEY_PATTERN = /\bsk-(?!ant-)[A-Za-z0-9]{20,}\b/g;
+var NPM_TOKEN_PATTERN = /\bnpm_[A-Za-z0-9]{36}\b/g;
+var JWT_PATTERN = /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g;
+var PEM_BLOCK_PATTERN = /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g;
+var BASIC_AUTH_URL_PATTERN = /(https?:\/\/)[^/\s:@]+:[^/\s@]+@/g;
+var GENERIC_SECRET_ASSIGNMENT_PATTERN = /\b((?:secret|password|passwd|api[_-]?key|access[_-]?key|client[_-]?secret|private[_-]?key)\s*[:=]\s*)[A-Za-z0-9+/_=-]{16,}\b/gi;
+function redactString(value, home) {
+  let out = value.replace(GITHUB_TOKEN_PATTERN, "<redacted>").replace(CLASSIC_GITHUB_PAT_PATTERN, "$1<redacted>").replace(BEARER_TOKEN_PATTERN, "<redacted>").replace(AWS_ACCESS_KEY_PATTERN, "<redacted>").replace(SLACK_TOKEN_PATTERN, "<redacted>").replace(STRIPE_KEY_PATTERN, "<redacted>").replace(ANTHROPIC_KEY_PATTERN, "<redacted>").replace(OPENAI_KEY_PATTERN, "<redacted>").replace(NPM_TOKEN_PATTERN, "<redacted>").replace(JWT_PATTERN, "<redacted>").replace(PEM_BLOCK_PATTERN, "<redacted>").replace(BASIC_AUTH_URL_PATTERN, "$1<redacted>@").replace(GENERIC_SECRET_ASSIGNMENT_PATTERN, "$1<redacted>");
+  if (home.length > 0 && out.startsWith(home)) {
+    const rest = out.slice(home.length);
+    if (rest === "" || rest.startsWith("/"))
+      out = `~${rest}`;
+  }
+  return out;
+}
+function redact(value, home) {
+  if (typeof value === "string")
+    return redactString(value, home);
+  if (Array.isArray(value))
+    return value.map((v) => redact(v, home));
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = redact(v, home);
+    }
+    return out;
+  }
+  return value;
+}
+// ../../packages/aeg-core/src/log/store.ts
+function metaOf(obj) {
+  if (obj === null || typeof obj !== "object")
+    return null;
+  const meta = obj.meta;
+  if (meta === null || typeof meta !== "object")
+    return null;
+  return meta;
+}
+function recordIdentity(obj) {
+  const meta = metaOf(obj);
+  if (meta === null)
+    return null;
+  const eventId = meta.event_id;
+  if (typeof eventId === "string" && eventId.length > 0)
+    return eventId;
+  const runId = meta.run_id;
+  const seq = meta.seq;
+  if (typeof runId === "string" && runId.length > 0 && typeof seq === "number" && Number.isInteger(seq)) {
+    return `${runId}:${seq}`;
+  }
+  return null;
+}
+
+// ../../packages/aeg-core/src/log/artifact.ts
+var TASK_LOG_ARTIFACT_MAX_BYTES = 8 * 1024 * 1024;
 // ../../packages/aeg-core/src/dev-review-loop/journal-reconstruction.ts
 var STOPPED_CONDITIONS = new Set(["confidence", "reappearance", "no_progress", "max_rounds"]);
 // ../../packages/aeg-core/src/control-store/records.ts
@@ -5670,7 +5939,9 @@ var RunRecordSchema = z3.object({
   runId: z3.string().min(1),
   pid: z3.number().int().positive(),
   host: z3.string().min(1),
-  startedAt: isoTimestamp
+  startedAt: isoTimestamp,
+  childStartedAt: z3.string().min(1).nullable().optional(),
+  childCommand: z3.string().min(1).nullable().optional()
 }).strict();
 var InputRecordSchema = z3.object({
   version: z3.literal(1),
@@ -5703,6 +5974,88 @@ var TransitionRecordSchema = z3.object({
   detail: z3.string().optional(),
   at: isoTimestamp
 }).strict();
+var ManifestRecordSchema = z3.object({
+  version: z3.literal(1),
+  kind: z3.literal("manifest"),
+  task: taskId,
+  round: epochNumber,
+  repository: z3.string().min(1),
+  pr: z3.number().int().positive(),
+  branch: z3.string().min(1),
+  baseSha: z3.string().min(1).nullable(),
+  headSha: z3.string().min(1),
+  briefHash: z3.string().min(1).nullable(),
+  objectivesVersion: z3.string().min(1).nullable(),
+  rulingOrdinal: epochNumber,
+  policyDigest: z3.string().min(1),
+  recordedAt: isoTimestamp
+}).strict();
+var roundHeadIdentity = z3.object({ round: z3.number().int().positive(), head: z3.string().min(1) }).strict();
+var LoopBudgetsSchema = z3.object({
+  mechanicalRetries: z3.number().int().nonnegative(),
+  reviewRounds: z3.number().int().nonnegative(),
+  infrastructureRetries: z3.number().int().nonnegative()
+}).strict();
+var LoopStateRecordSchema = z3.object({
+  version: z3.literal(1),
+  kind: z3.literal("loop_state"),
+  task: taskId,
+  round: z3.number().int().positive(),
+  phase: z3.string().min(1),
+  pauseReason: z3.string().min(1).nullable(),
+  budgets: LoopBudgetsSchema,
+  heldResult: roundHeadIdentity.nullable(),
+  deliveredFindings: roundHeadIdentity.nullable(),
+  recordedAt: isoTimestamp
+}).strict();
+var EffectRecordSchema = z3.object({
+  version: z3.literal(1),
+  kind: z3.literal("effect"),
+  task: taskId,
+  key: z3.string().min(1),
+  operation: z3.string().min(1),
+  target: z3.string().min(1),
+  inputVersion: z3.number().int().nonnegative(),
+  payloadDigest: z3.string().min(1),
+  status: z3.union([z3.literal("started"), z3.literal("verified"), z3.literal("uncertain")]),
+  url: z3.string().optional(),
+  recordedAt: isoTimestamp
+}).strict();
+var EscalationRecordSchema = z3.object({
+  version: z3.literal(1),
+  kind: z3.literal("escalation"),
+  task: taskId,
+  escalationId: z3.string().min(1),
+  round: epochNumber,
+  head: z3.string().min(1),
+  branch: z3.string().min(1),
+  pr: z3.number().int().positive().nullable(),
+  runId: z3.string().min(1),
+  pid: z3.number().int().positive(),
+  host: z3.string().min(1),
+  agent: z3.string().min(1).optional(),
+  reason: z3.string().min(1),
+  detail: z3.string().optional(),
+  evidence: z3.string().optional(),
+  attemptedRecovery: z3.string().min(1),
+  requestedDecision: z3.string().min(1),
+  recipient: z3.string().min(1),
+  briefHash: z3.string().min(1).nullable(),
+  objectivesVersion: z3.string().min(1).nullable(),
+  rulingOrdinal: epochNumber,
+  policyDigest: z3.string().min(1),
+  recordedAt: isoTimestamp
+}).strict();
+var ResolutionRecordSchema = z3.object({
+  version: z3.literal(1),
+  kind: z3.literal("resolution"),
+  task: taskId,
+  escalationId: z3.string().min(1),
+  decision: z3.union([z3.literal("resume"), z3.literal("cancel")]),
+  authenticatedBy: z3.string().min(1),
+  authenticatedFrom: z3.string().min(1),
+  consumedAt: isoTimestamp
+}).strict();
 // src/lib/config.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync as readFileSync2, realpathSync, writeFileSync } from "node:fs";
@@ -5883,6 +6236,13 @@ var VinayaConfigSchema = z4.object({
         message: "must be at most 3600000 (1 hour)"
       });
     }
+  }).optional(),
+  logPublish: z4.object({
+    issue: z4.number().int().positive().optional(),
+    pr: z4.number().int().positive().optional(),
+    maxChunksPerFlush: z4.number().int().positive().optional()
+  }).refine((v) => !(v.issue !== undefined && v.pr !== undefined), {
+    message: "logPublish: set at most one of issue/pr, not both"
   }).optional()
 });
 var GLOBAL_VINAYA_HOME = join(homedir(), ".vinaya");
@@ -6230,6 +6590,16 @@ var COMMANDS = [
     ],
     status: "shipped"
   },
+  {
+    name: "task-tools serve",
+    description: "Run the task-operator MCP tool server over stdio — the command both runtime adapters register",
+    details: [
+      "Exposes the task-operator tool catalog (`packages/aeg-core/src/task-tools.ts`) to an agent runtime as one MCP server speaking newline-delimited JSON-RPC 2.0 (`initialize`/`tools/list`/`tools/call`). Claude registers it through the generated `.mcp.json`; Codex through its documented `~/.codex/config.toml` `[mcp_servers]` table — both point at this same command.",
+      "stdout carries JSON-RPC and nothing else: any stray write from the CLI (a forge-read warning) is redirected to stderr, so the protocol stream is never corrupted.",
+      "`task_status`/`task_escalation_read` read; `task_start` starts a run in attended mode only, requiring an authenticated caller from the invocation context (`VINAYA_MCP_CALLER`) and refusing without one — MCP is a transport, not authorization. `task_resume`/`task_cancel` require the same authenticated caller, plus a current Principal ruling read fresh from the run's own PR — never a caller-supplied approval; `task_resume` triggers the existing `dev-review-loop --resume` continuation exactly once per escalation, and `task_cancel` reports a truthful `confirmed`/`pending`/`uncertain` outcome, idempotently, across repeated calls. No unattended start until the worker-isolation boundary and a capability flag land."
+    ],
+    status: "shipped"
+  },
   {
     name: "pr create",
     description: "Open a pull request after full brief-schema validation",
@@ -6374,6 +6744,30 @@ var COMMANDS = [
     ],
     status: "shipped"
   },
+  {
+    name: "log export-artifact",
+    description: "Copy this run's own local outbox into a file, for the generated task-path workflow's own upload step",
+    flags: [],
+    details: [
+      "Concatenates every `*.ndjson` file under `~/.vinaya/outbox/` into `<dest>`, verbatim — no filtering, no second redaction pass (lines are already redacted at `log()`'s own write boundary). Writes nothing when the outbox is empty, and exits 0 either way: no gate events this run is a legitimate outcome, never a failure.",
+      "Runs inside the generated `vinaya-checks.yml` job, which holds no forge-write credential — this command never calls the forge. Both this step and the `actions/upload-artifact` step after it run `if: always()`, so a cancelled or failed job still exports whatever partial outbox it has."
+    ],
+    status: "shipped"
+  },
+  {
+    name: "log collect-artifact",
+    description: "Validate a downloaded task-log artifact and publish the valid records through the existing flush path",
+    flags: [
+      { flag: "--pr", description: "The pull request this artifact belongs to" },
+      { flag: "--repo", description: "Expected `owner/repo` — a provenance cross-check against each record" }
+    ],
+    details: [
+      "Runs inside the generated `vinaya-task-log-collector.yml` workflow — a `workflow_run`-triggered job on the default branch, holding the write credential the task-path job that produced the artifact never gets. `<path>` is already downloaded by that workflow, scoped to a specific, API-verified run id — a provenance guarantee this command never re-derives from the artifact bytes.",
+      "Never executes, imports, or evaluates the artifact's content: every line is read as text and validated (schema, an 8 MiB whole-artifact size cap, redaction, and a repo cross-check) before anything is trusted. A rejected line becomes a named gap — printed, never a silent drop — and the artifact is never partially trusted past that check into executing anything.",
+      "The valid, re-redacted survivors are appended into the same local outbox `vinaya log flush` would read for that PR's Issue, then published through the existing `flushOutbox` unmodified — reusing its chunking, its `<!-- aeg:log:… -->` marker, and its idempotent-retry read, rather than a second publisher. A retried collector run (a fresh runner, the same forge state) therefore dedupes for free: the marker already on the forge is acknowledged, never re-posted."
+    ],
+    status: "shipped"
+  },
   {
     name: "milestone create",
     description: "Create a GitHub Milestone from a validated body",
@@ -7436,8 +7830,254 @@ function coreCheckRegistry() {
 }
 var CORE_CHECK_RING = Object.fromEntries(REGISTRY.map(([spec, ring]) => [spec.name, ring]));
 
+// src/lib/log-sink.ts
+import { execFileSync as execFileSync5 } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import {
+  closeSync as closeSync2,
+  constants as fsConstants2,
+  existsSync as existsSync4,
+  fstatSync as fstatSync2,
+  mkdirSync as mkdirSync2,
+  openSync as openSync2,
+  readFileSync as readFileSync3,
+  renameSync,
+  writeSync
+} from "node:fs";
+import { hostname as osHostname, homedir as homedir2 } from "node:os";
+import { dirname as dirname3, join as join4 } from "node:path";
+var OUTBOX_MAX_BYTES = 8 * 1024 * 1024;
+function isEnoent(err) {
+  return typeof err === "object" && err !== null && err.code === "ENOENT";
+}
+function resolveDoctrine(cwd, vinayaVersion) {
+  let toplevel;
+  try {
+    toplevel = execFileSync5("git", ["-C", cwd, "rev-parse", "--show-toplevel"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+  } catch (err) {
+    return isEnoent(err) ? "unknown" : vinayaVersion;
+  }
+  if (!existsSync4(join4(toplevel, "aeg-root", "roles")))
+    return vinayaVersion;
+  try {
+    const sha = execFileSync5("git", ["-C", toplevel, "rev-parse", "HEAD:aeg-root"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+    return `aeg-root@${sha}`;
+  } catch {
+    return vinayaVersion;
+  }
+}
+function readVinayaVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync3(join4(packageRoot(import.meta.url), "package.json"), "utf8"));
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+var SAFE_PATH_SEGMENT = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/;
+function isSafeRepoSegment(segment) {
+  return SAFE_PATH_SEGMENT.test(segment) && !segment.includes("..");
+}
+function outboxPathFor(deps, repo, issue) {
+  const dirName = repo ? `${repo.owner}-${repo.repo}` : "unresolved";
+  const fileName = `${issue ?? "none"}.ndjson`;
+  return join4(deps.outboxRoot(), dirName, fileName);
+}
+function hostFromEnv(env) {
+  if (env.GITHUB_ACTIONS)
+    return "ci";
+  if (env.VINAYA_HOST === "hook")
+    return "hook";
+  if (env.VINAYA_HOST === "loop")
+    return "loop";
+  return "cli";
+}
+function defaultDeps() {
+  return {
+    outboxRoot: () => join4(GLOBAL_VINAYA_HOME, "outbox"),
+    home: () => homedir2(),
+    hostname: () => osHostname(),
+    cwd: () => process.cwd(),
+    now: () => new Date,
+    env: () => process.env,
+    resolveRepo: () => resolveRepo(),
+    vinayaVersion: () => readVinayaVersion(),
+    stderr: (message) => {
+      process.stderr.write(message);
+    },
+    inputVersions: () => {
+      return;
+    }
+  };
+}
+var APPEND_OPEN_FLAGS = fsConstants2.O_WRONLY | fsConstants2.O_APPEND | fsConstants2.O_CREAT | fsConstants2.O_NOFOLLOW | fsConstants2.O_NONBLOCK;
+function guardedAppendOpen(path) {
+  try {
+    return openSync2(path, APPEND_OPEN_FLAGS, 384);
+  } catch {
+    return;
+  }
+}
+function reportRotationOverflow(backupPath, warn) {
+  let raw;
+  try {
+    raw = readFileSync3(backupPath, "utf8");
+  } catch {
+    return;
+  }
+  const lines = raw.split(`
+`).filter((l) => l.length > 0);
+  if (lines.length === 0)
+    return;
+  const droppedIdentities = lines.map((line, i) => {
+    try {
+      return recordIdentity(JSON.parse(line)) ?? `unreadable:${i}`;
+    } catch {
+      return `unreadable:${i}`;
+    }
+  });
+  const diagnostic = { reason: "capacity", dropped: droppedIdentities.length, droppedIdentities };
+  const shown = diagnostic.droppedIdentities.slice(0, 20);
+  const more = diagnostic.dropped > shown.length ? `, +${diagnostic.dropped - shown.length} more` : "";
+  warn(`vinaya: log outbox rotation is overwriting ${backupPath} — ${diagnostic.dropped} record(s) permanently lost: ${shown.join(", ")}${more}
+`);
+}
+function appendLine(path, line, warn) {
+  try {
+    mkdirSync2(dirname3(path), { recursive: true, mode: 448 });
+    let fd = guardedAppendOpen(path);
+    if (fd === undefined) {
+      warn(`vinaya: log outbox target could not be opened (symlink, FIFO, or unwritable) — refusing: ${path}
+`);
+      return;
+    }
+    let closed = false;
+    try {
+      const stat = fstatSync2(fd);
+      if (!stat.isFile()) {
+        warn(`vinaya: log outbox target is not a regular file — refusing to write: ${path}
+`);
+        return;
+      }
+      if (stat.size > OUTBOX_MAX_BYTES) {
+        closeSync2(fd);
+        closed = true;
+        const backupPath = path.replace(/\.ndjson$/, ".1.ndjson");
+        reportRotationOverflow(backupPath, warn);
+        renameSync(path, backupPath);
+        const rotated = guardedAppendOpen(path);
+        if (rotated === undefined) {
+          warn(`vinaya: log outbox target could not be reopened after rotation — refusing: ${path}
+`);
+          return;
+        }
+        fd = rotated;
+        closed = false;
+      }
+      writeSync(fd, line);
+    } finally {
+      if (!closed)
+        closeSync2(fd);
+    }
+  } catch (err) {
+    warn(`vinaya: log outbox write failed — ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+}
+function createLogSink(overrides = {}) {
+  const deps = { ...defaultDeps(), ...overrides };
+  const runId = deps.env().VINAYA_RUN_ID || randomUUID();
+  const processId = randomUUID();
+  let seq = 0;
+  let warned = false;
+  const warnOnce = (message) => {
+    if (warned)
+      return;
+    warned = true;
+    try {
+      deps.stderr(message);
+    } catch {}
+  };
+  let doctrineCache;
+  const doctrine = () => {
+    if (doctrineCache === undefined)
+      doctrineCache = resolveDoctrine(deps.cwd(), deps.vinayaVersion());
+    return doctrineCache;
+  };
+  let resolveRepoCache;
+  const resolveRepoOnce = () => {
+    if (resolveRepoCache === undefined)
+      resolveRepoCache = deps.resolveRepo();
+    return resolveRepoCache;
+  };
+  function log(e) {
+    try {
+      const env = deps.env();
+      const host = hostFromEnv(env);
+      const now = deps.now();
+      const mySeq = seq++;
+      resolveRepoOnce().then((resolved) => {
+        const repo = resolved && isSafeRepoSegment(resolved.owner) && isSafeRepoSegment(resolved.repo) ? resolved : null;
+        const header = buildHeader({
+          now,
+          runId,
+          seq: mySeq,
+          repo: repo ? `${repo.owner}/${repo.repo}` : null,
+          vinaya: deps.vinayaVersion(),
+          doctrine: doctrine(),
+          host,
+          hostname: deps.hostname(),
+          env: {
+            role: env.VINAYA_ROLE,
+            task: env.VINAYA_TASK,
+            round: env.VINAYA_ROUND,
+            run: env.VINAYA_RUN,
+            attempt: env.VINAYA_ATTEMPT,
+            parent: env.VINAYA_PARENT_EVENT
+          },
+          eventId: randomUUID(),
+          processId,
+          inputVersions: deps.inputVersions()
+        });
+        const full = { ...e, ...header };
+        const parsed = LogEventSchema.safeParse(full);
+        if (!parsed.success) {
+          warnOnce(`vinaya: log() refused an invalid payload — ${parsed.error.issues[0]?.message ?? "schema violation"}
+`);
+          return;
+        }
+        const line = `${JSON.stringify(redact(parsed.data, deps.home()))}
+`;
+        appendLine(outboxPathFor(deps, repo, header.subject.issue), line, warnOnce);
+      }).catch((err) => {
+        warnOnce(`vinaya: log() failed — ${err instanceof Error ? err.message : String(err)}
+`);
+      });
+    } catch (err) {
+      warnOnce(`vinaya: log() failed — ${err instanceof Error ? err.message : String(err)}
+`);
+    }
+  }
+  const warmup = () => {
+    doctrine();
+    const originalWarn = console.warn;
+    console.warn = () => {};
+    resolveRepoOnce().finally(() => {
+      console.warn = originalWarn;
+    });
+  };
+  return { log, runId, warmup };
+}
+var defaultSink = createLogSink();
+
 // src/checks/runner.ts
-var activeKillers = new Set;
+var activeChecks = new Map;
 
 // src/lib/forge-write.ts
 var INFORMATIONAL_DISPATCH_BLOCKER_CLASSES = new Set([
@@ -7476,7 +8116,7 @@ function parseChangedLineRanges(diffOutput) {
 function fileDiffAgainst(ref, path) {
   let out;
   try {
-    out = execFileSync5("git", ["diff", `${ref}...HEAD`, "--", path], {
+    out = execFileSync6("git", ["diff", `${ref}...HEAD`, "--", path], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
     }).trim();
@@ -7487,7 +8127,7 @@ function fileDiffAgainst(ref, path) {
 }
 function revParse(ref) {
   try {
-    return execFileSync5("git", ["rev-parse", "--verify", ref], {
+    return execFileSync6("git", ["rev-parse", "--verify", ref], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
     }).trim();
@@ -7497,7 +8137,7 @@ function revParse(ref) {
 }
 function repoRoot() {
   try {
-    return execFileSync5("git", ["rev-parse", "--show-toplevel"], {
+    return execFileSync6("git", ["rev-parse", "--show-toplevel"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
     }).trim();
@@ -7508,7 +8148,7 @@ function repoRoot() {
 function changedFiles(base) {
   let out;
   try {
-    out = execFileSync5("git", ["diff", "--name-only", `${base}...HEAD`], {
+    out = execFileSync6("git", ["diff", "--name-only", `${base}...HEAD`], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
     }).trim();
@@ -7533,7 +8173,7 @@ function resolveDiff(base = process.env.BASE_SHA || "origin/main") {
     const relPaths = changedFiles(ref);
     if (relPaths === null)
       continue;
-    return { base: ref, root, files: relPaths.map((p) => join4(root, p)) };
+    return { base: ref, root, files: relPaths.map((p) => join5(root, p)) };
   }
   return null;
 }
@@ -7569,7 +8209,7 @@ var CHECK_NAME = "exec-bits";
 var EXECUTABLE_MODE = "100755";
 function git2(args) {
   try {
-    return execFileSync6("git", args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+    return execFileSync7("git", args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
   } catch {
     return null;
   }
@@ -7583,7 +8223,7 @@ function indexMode(path) {
 }
 function hasShebang(path) {
   try {
-    return readFileSync3(path, "utf8").startsWith("#!");
+    return readFileSync4(path, "utf8").startsWith("#!");
   } catch {
     return false;
   }