@attalabs/vinaya 0.28.0 → 0.29.0

package/dist/checks/bin/check-coherence.js

@@ -1647,6 +1647,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);
@@ -1959,6 +2005,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(`
@@ -1994,6 +2041,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) => ({
@@ -2011,6 +2067,7 @@ function extractVerdict(comments, valuePattern, missingLabel) {
       rulingOrdinal: null,
       briefHash: null,
       policyDigest: null,
+      baseSha: null,
       findingSeverities: [],
       danglingNote: `no ${missingLabel} verdict comment found on this PR`
     };
@@ -2025,6 +2082,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`
     };
@@ -2036,6 +2094,7 @@ function extractVerdict(comments, valuePattern, missingLabel) {
     rulingOrdinal: extractRulingOrdinal(latest),
     briefHash: extractBriefHash(latest),
     policyDigest: extractPolicyDigest(latest),
+    baseSha: extractBaseSha(latest),
     findingSeverities: extractFindingSeverities(latest),
     danglingNote: null
   };
@@ -3949,7 +4008,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)
@@ -3965,8 +4028,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)
@@ -3987,14 +4054,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,
@@ -4046,6 +4117,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,
@@ -4053,6 +4125,7 @@ function checkReviewGate(input) {
   };
   const codeReviewEchoed = {
     headSha: codeReview.headSha,
+    baseSha: codeReview.baseSha,
     briefHash: codeReview.briefHash,
     objectivesVersion: codeReview.objectivesVersion,
     rulingOrdinal: codeReview.rulingOrdinal,
@@ -4060,6 +4133,7 @@ function checkReviewGate(input) {
   };
   const securityEchoed = {
     headSha: security.headSha,
+    baseSha: security.baseSha,
     briefHash: security.briefHash,
     objectivesVersion: security.objectivesVersion,
     rulingOrdinal: security.rulingOrdinal,
@@ -4087,6 +4161,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) {
@@ -4102,6 +4178,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) {
@@ -4959,8 +5037,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({
@@ -4974,7 +5052,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(),
@@ -4998,9 +5076,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(),
@@ -5008,7 +5097,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),
@@ -5017,15 +5108,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);
@@ -5248,6 +5372,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 = [
@@ -5349,7 +5476,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,
@@ -5409,7 +5537,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,
@@ -5588,7 +5717,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({
@@ -5647,6 +5778,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
@@ -5661,7 +5930,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),
@@ -5694,6 +5965,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();
 // ../../packages/sources/src/commands.ts
 var COMMANDS = [
   {
@@ -5863,6 +6216,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",
@@ -6007,6 +6370,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",
@@ -6564,6 +6951,13 @@ var VinayaConfigSchema = z5.object({
         message: "must be at most 3600000 (1 hour)"
       });
     }
+  }).optional(),
+  logPublish: z5.object({
+    issue: z5.number().int().positive().optional(),
+    pr: z5.number().int().positive().optional(),
+    maxChunksPerFlush: z5.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");