@open330/oac 2026.222.1 → 2026.222.2

package/dist/{chunk-GPHH2IYN.js → chunk-ATVWSG75.js}

@@ -32,12 +32,12 @@ import {
   createSandbox,
   epicAsTask,
   executeTask
-} from "./chunk-JROCVTM7.js";
+} from "./chunk-27FEE5KS.js";
 import {
   UNLIMITED_BUDGET,
   createEventBus,
   loadConfig
-} from "./chunk-7C7SC4TZ.js";
+} from "./chunk-I3TKNT4M.js";
 import {
   isRecord,
   truncate
@@ -729,8 +729,8 @@ function isVersionAtLeast(version, minimum) {
 }
 async function runCommand(command, args) {
   try {
-    const { execa: execa3 } = await import("execa");
-    const result = await execa3(command, args, {
+    const { execa: execa4 } = await import("execa");
+    const result = await execa4(command, args, {
       reject: false,
       timeout: 1e4,
       stdin: "ignore"
@@ -1589,12 +1589,10 @@ import { Command as Command9 } from "commander";
 // src/cli/commands/run/pipeline.ts
 import { randomUUID } from "crypto";
 
-// src/cli/commands/run/epic.ts
-import Table6 from "cli-table3";
-import PQueue3 from "p-queue";
-
-// src/cli/commands/run/pr.ts
-import { execa } from "execa";
+// src/cli/commands/run/context-policy.ts
+import { createHash } from "crypto";
+import { readFile as readFile5, readdir as readdir3, stat } from "fs/promises";
+import { join, relative, resolve as resolve6 } from "path";
 
 // src/cli/commands/run/types.ts
 var DEFAULT_TIMEOUT_SECONDS = 300;
@@ -1636,7 +1634,140 @@ function formatDuration(seconds) {
   return `${minutes}m ${remainingSeconds}s`;
 }
 
+// src/cli/commands/run/context-policy.ts
+async function resolveContextAck(repoPath, config, ui, suppressOutput) {
+  const mode = config?.context.mode ?? "off";
+  if (mode === "off") {
+    return void 0;
+  }
+  const requiredGlobs = (config?.context.requiredGlobs ?? []).filter(
+    (item) => item.trim().length > 0
+  );
+  if (requiredGlobs.length === 0) {
+    return void 0;
+  }
+  const files = await collectFilesForGlobs(repoPath, requiredGlobs);
+  if (files.length === 0) {
+    const message = `Missing required context files for run policy (${requiredGlobs.join(
+      ", "
+    )}). Create repository-owned markdown plans under .context/plans and retry.`;
+    if (mode === "enforce") {
+      throw new ConfigError(message);
+    }
+    if (!suppressOutput) {
+      console.warn(ui.yellow(`[oac] Context policy warning: ${message}`));
+    }
+    return void 0;
+  }
+  const maxItems = config?.context.maxAckItems ?? 3;
+  const summary = await summarizeContextFiles(repoPath, files.slice(0, maxItems));
+  const digest = await hashContextFiles(repoPath, files);
+  if (!suppressOutput) {
+    console.log(
+      ui.blue(
+        `[oac] Context policy loaded ${files.length} file(s): ${files.slice(0, maxItems).join(", ")}`
+      )
+    );
+  }
+  return {
+    mode,
+    requiredGlobs,
+    files,
+    summary,
+    digest
+  };
+}
+async function collectFilesForGlobs(repoPath, globs) {
+  const files = /* @__PURE__ */ new Set();
+  for (const pattern of globs) {
+    const root = resolveSearchRoot(repoPath, pattern);
+    const rootStat = await safeStat(root);
+    if (!rootStat?.isDirectory()) continue;
+    const candidates = await listFilesRecursively(root);
+    const matcher = createSimpleGlobMatcher(pattern);
+    for (const candidate of candidates) {
+      const relPath = toPosixPath(relative(repoPath, candidate));
+      if (matcher(relPath)) {
+        files.add(relPath);
+      }
+    }
+  }
+  return [...files].sort((a, b) => a.localeCompare(b));
+}
+function resolveSearchRoot(repoPath, pattern) {
+  const normalized = toPosixPath(pattern);
+  const wildcardIndex = normalized.search(/[\[*?]/);
+  const prefix = wildcardIndex === -1 ? normalized : normalized.slice(0, wildcardIndex);
+  const cleanedPrefix = prefix.replace(/\/+$|\/+$/g, "");
+  const fallback = ".";
+  return resolve6(repoPath, cleanedPrefix.length > 0 ? cleanedPrefix : fallback);
+}
+function createSimpleGlobMatcher(pattern) {
+  const tokenized = toPosixPath(pattern).replaceAll("**/", "::DOUBLE_STAR_DIR::").replaceAll("**", "::DOUBLE_STAR::").replaceAll("*", "::STAR::").replaceAll("?", "::QUESTION::");
+  const escaped = tokenized.replace(/[\\.^$+{}()|[\]]/g, "\\$&").replaceAll("::DOUBLE_STAR_DIR::", "(?:.*/)?").replaceAll("::DOUBLE_STAR::", ".*").replaceAll("::STAR::", "[^/]*").replaceAll("::QUESTION::", "[^/]");
+  const regex = new RegExp(`^${escaped}$`);
+  return (path) => regex.test(toPosixPath(path));
+}
+async function listFilesRecursively(rootDir) {
+  const output = [];
+  const queue = [rootDir];
+  while (queue.length > 0) {
+    const current = queue.pop();
+    if (!current) continue;
+    const entries = await readdir3(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(current, entry.name);
+      if (entry.isDirectory()) {
+        queue.push(fullPath);
+      } else if (entry.isFile()) {
+        output.push(fullPath);
+      }
+    }
+  }
+  return output;
+}
+async function summarizeContextFiles(repoPath, relPaths) {
+  const lines = [];
+  for (const relPath of relPaths) {
+    const fullPath = resolve6(repoPath, relPath);
+    const content = await readFile5(fullPath, "utf8");
+    const condensed = content.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0).filter((line) => line.startsWith("#") || line.startsWith("-") || line.startsWith("*"));
+    const selected = condensed.slice(0, 3);
+    if (selected.length > 0) {
+      lines.push(`${relPath}: ${selected.join(" | ")}`);
+    }
+  }
+  return lines;
+}
+async function hashContextFiles(repoPath, relPaths) {
+  const hash = createHash("sha256");
+  for (const relPath of relPaths) {
+    const fullPath = resolve6(repoPath, relPath);
+    const content = await readFile5(fullPath, "utf8");
+    hash.update(relPath);
+    hash.update("\n");
+    hash.update(content);
+    hash.update("\n");
+  }
+  return hash.digest("hex");
+}
+async function safeStat(path) {
+  try {
+    return await stat(path);
+  } catch {
+    return void 0;
+  }
+}
+function toPosixPath(value) {
+  return value.replaceAll("\\", "/");
+}
+
+// src/cli/commands/run/epic.ts
+import Table6 from "cli-table3";
+import PQueue3 from "p-queue";
+
 // src/cli/commands/run/pr.ts
+import { execa } from "execa";
 var GITHUB_API_BASE_URL = "https://api.github.com";
 var OAC_PR_TITLE_PREFIX = "[OAC]";
 async function createPullRequest(input2) {
@@ -1689,6 +1820,23 @@ async function createPullRequest(input2) {
     if (input2.task.linkedIssue) {
       prBodyLines.push(`- **Resolves:** #${input2.task.linkedIssue.number}`);
     }
+    const contextAck = readContextAck(input2.task);
+    if (contextAck) {
+      prBodyLines.push("", "## Repository Policy Acknowledgement", "");
+      prBodyLines.push("- **Context files read:**");
+      for (const file of contextAck.files.slice(0, 5)) {
+        prBodyLines.push(`  - \`${file}\``);
+      }
+      if (contextAck.summary.length > 0) {
+        prBodyLines.push("", "- **Policy summary used:**");
+        for (const line of contextAck.summary.slice(0, 5)) {
+          prBodyLines.push(`  - ${line}`);
+        }
+      }
+      if (contextAck.digest) {
+        prBodyLines.push("", `- **Context digest:** \`${contextAck.digest}\``);
+      }
+    }
     prBodyLines.push(
       "",
       "---",
@@ -1727,6 +1875,23 @@ async function createPullRequest(input2) {
     return void 0;
   }
 }
+function readContextAck(task) {
+  if (!task.metadata || typeof task.metadata !== "object" || task.metadata === null) {
+    return void 0;
+  }
+  const raw = task.metadata.contextAck;
+  if (!raw || typeof raw !== "object") return void 0;
+  const record = raw;
+  const files = Array.isArray(record.files) ? record.files.filter(
+    (item) => typeof item === "string" && item.trim().length > 0
+  ) : [];
+  if (files.length === 0) return void 0;
+  const summary = Array.isArray(record.summary) ? record.summary.filter(
+    (item) => typeof item === "string" && item.trim().length > 0
+  ) : [];
+  const digest = typeof record.digest === "string" && record.digest.trim().length > 0 ? record.digest : void 0;
+  return { files, summary, digest };
+}
 async function findExistingOacPR(repoFullName, issueNumber, token) {
   const url = `${GITHUB_API_BASE_URL}/repos/${repoFullName}/pulls?state=open&per_page=100&sort=updated&direction=desc`;
   try {
@@ -1768,8 +1933,186 @@ async function findExistingOacPR(repoFullName, issueNumber, token) {
 
 // src/cli/commands/run/task.ts
 import Table5 from "cli-table3";
-import { execa as execa2 } from "execa";
+import { execa as execa3 } from "execa";
 import PQueue2 from "p-queue";
+
+// src/cli/commands/run/tracking.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { join as join2, resolve as resolve7 } from "path";
+import { execa as execa2 } from "execa";
+async function writeTracking(ctx, params) {
+  const { resolvedRepo, providerId, totalBudget, candidateTasks, completedTasks } = params;
+  const runDurationSeconds = (Date.now() - ctx.runStartedAt) / 1e3;
+  const contributionLog = buildContributionLog({
+    runId: ctx.runId,
+    repoFullName: resolvedRepo.fullName,
+    repoHeadSha: resolvedRepo.git.headSha,
+    defaultBranch: resolvedRepo.meta.defaultBranch,
+    repoOwner: resolvedRepo.owner,
+    providerId,
+    totalBudget,
+    runDurationSeconds,
+    discoveredTasks: candidateTasks.length,
+    taskResults: completedTasks
+  });
+  const trackingSpinner = createSpinner(ctx.suppressOutput, "Writing contribution log...");
+  try {
+    const logPath = await writeContributionLog(contributionLog, resolvedRepo.localPath);
+    trackingSpinner?.succeed(`Contribution log written: ${logPath}`);
+    return logPath;
+  } catch (error) {
+    trackingSpinner?.fail("Failed to write contribution log");
+    if (ctx.globalOptions.verbose && !ctx.suppressOutput) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(ctx.ui.yellow(`[oac] Tracking failed: ${message}`));
+    }
+    return void 0;
+  }
+}
+function buildContributionLog(input2) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const contributor = resolveGithubUsername(input2.repoOwner);
+  const contributionTasks = input2.taskResults.map((result) => ({
+    taskId: result.task.id,
+    title: result.task.title,
+    source: result.task.source,
+    complexity: result.task.complexity,
+    status: deriveTaskStatus(result.execution),
+    tokensUsed: Math.max(0, Math.floor(result.execution.totalTokensUsed)),
+    duration: Math.max(0, result.execution.duration),
+    filesChanged: result.execution.filesChanged,
+    pr: result.pr,
+    linkedIssue: result.task.linkedIssue ? {
+      number: result.task.linkedIssue.number,
+      url: result.task.linkedIssue.url
+    } : void 0,
+    error: result.execution.error
+  }));
+  const tasksSucceeded = contributionTasks.filter((task) => task.status !== "failed").length;
+  const tasksFailed = contributionTasks.length - tasksSucceeded;
+  const totalTokensUsed = contributionTasks.reduce((sum, task) => sum + task.tokensUsed, 0);
+  const totalFilesChanged = contributionTasks.reduce(
+    (sum, task) => sum + task.filesChanged.length,
+    0
+  );
+  return {
+    version: "1.0",
+    runId: input2.runId,
+    timestamp,
+    contributor: {
+      githubUsername: contributor,
+      email: process.env.GIT_AUTHOR_EMAIL ?? void 0
+    },
+    repo: {
+      fullName: input2.repoFullName,
+      headSha: input2.repoHeadSha,
+      defaultBranch: input2.defaultBranch
+    },
+    budget: {
+      provider: input2.providerId,
+      totalTokensBudgeted: input2.totalBudget,
+      totalTokensUsed
+    },
+    tasks: contributionTasks,
+    metrics: {
+      tasksDiscovered: input2.discoveredTasks,
+      tasksAttempted: contributionTasks.length,
+      tasksSucceeded,
+      tasksFailed,
+      totalDuration: Math.max(0, input2.runDurationSeconds),
+      totalFilesChanged,
+      totalLinesAdded: 0,
+      totalLinesRemoved: 0
+    }
+  };
+}
+function deriveTaskStatus(execution) {
+  if (execution.success) {
+    return "success";
+  }
+  if (execution.filesChanged.length > 0) {
+    return "partial";
+  }
+  return "failed";
+}
+function resolveGithubUsername(fallback) {
+  const candidates = [
+    process.env.GITHUB_USER,
+    process.env.GITHUB_USERNAME,
+    process.env.USER,
+    process.env.LOGNAME,
+    fallback,
+    "oac-user"
+  ];
+  for (const candidate of candidates) {
+    const normalized = sanitizeGithubUsername(candidate ?? "");
+    if (normalized) {
+      return normalized;
+    }
+  }
+  return "oac-user";
+}
+function sanitizeGithubUsername(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const cleaned = trimmed.replace(/[^A-Za-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  if (cleaned.length === 0 || cleaned.length > 39) {
+    return null;
+  }
+  if (!/^(?!-)[A-Za-z0-9-]+(?<!-)$/.test(cleaned)) {
+    return null;
+  }
+  return cleaned;
+}
+async function writeContributionToSandbox(input2) {
+  const { sandboxPath, task, execution, runId, repoOwner } = input2;
+  const contributionsDir = resolve7(sandboxPath, ".oac", "contributions");
+  await mkdir2(contributionsDir, { recursive: true });
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const contributor = resolveGithubUsername(repoOwner);
+  const datePrefix = timestamp.replace(/[:.]/g, "").replace("T", "-").slice(0, 15);
+  const safeTaskId = task.id.replace(/[^A-Za-z0-9-]/g, "-").replace(/-+/g, "-").slice(0, 40);
+  const filename = `${datePrefix}-${safeTaskId}.json`;
+  const metadata = {
+    version: "1.0",
+    runId,
+    timestamp,
+    contributor,
+    task: {
+      id: task.id,
+      title: task.title,
+      source: task.source,
+      complexity: task.complexity,
+      contextAck: isRecord2(task.metadata.contextAck) && Array.isArray(task.metadata.contextAck.files) ? {
+        files: task.metadata.contextAck.files,
+        summary: Array.isArray(task.metadata.contextAck.summary) ? task.metadata.contextAck.summary : [],
+        digest: typeof task.metadata.contextAck.digest === "string" ? task.metadata.contextAck.digest : void 0
+      } : void 0,
+      linkedIssue: task.linkedIssue ? { number: task.linkedIssue.number, url: task.linkedIssue.url } : void 0
+    },
+    execution: {
+      success: execution.success,
+      tokensUsed: execution.totalTokensUsed,
+      duration: execution.duration,
+      filesChanged: execution.filesChanged
+    }
+  };
+  const filePath = join2(contributionsDir, filename);
+  await writeFile2(filePath, `${JSON.stringify(metadata, null, 2)}
+`, "utf8");
+  try {
+    await execa2("git", ["add", filePath], { cwd: sandboxPath });
+    await execa2("git", ["commit", "-m", "[OAC] Add contribution metadata"], { cwd: sandboxPath });
+  } catch {
+  }
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/cli/commands/run/task.ts
 async function discoverTasks(ctx, options, config, ghToken, resolvedRepo) {
   const scannerSelection = selectScannersFromConfig2(config, Boolean(ghToken));
   const minPriority = config?.discovery.minPriority ?? 20;
@@ -1899,8 +2242,9 @@ async function executePlan(ctx, params) {
   const executedTasks = await Promise.all(
     plan.selectedTasks.map(
       (entry) => taskQueue.add(async () => {
+        const taskForExecution = withContextAck(entry.task, ctx.contextAck);
         const result = await executeWithAgent({
-          task: entry.task,
+          task: taskForExecution,
           estimate: entry.estimate,
           adapter,
           repoPath: resolvedRepo.localPath,
@@ -1914,7 +2258,7 @@ async function executePlan(ctx, params) {
           const pct = Math.round(completedCount / total * 100);
           executionSpinner.text = `Executing tasks... (${completedCount}/${total} \u2014 ${pct}%)`;
         }
-        return { task: entry.task, estimate: entry.estimate, execution, sandbox };
+        return { task: taskForExecution, estimate: entry.estimate, execution, sandbox };
       })
     )
   );
@@ -1925,6 +2269,16 @@ async function executePlan(ctx, params) {
     executedTasks.map(
       (result) => completionQueue.add(async () => {
         if (mode === "direct-commit" || !result.execution.success) return result;
+        if (result.sandbox) {
+          await writeContributionToSandbox({
+            sandboxPath: result.sandbox.sandboxPath,
+            task: result.task,
+            execution: result.execution,
+            runId: ctx.runId,
+            repoFullName: resolvedRepo.fullName,
+            repoOwner: resolvedRepo.owner
+          });
+        }
         const pr = await createPullRequest({
           task: result.task,
           execution: result.execution,
@@ -1994,6 +2348,18 @@ function selectScannersFromConfig2(config, hasGitHubAuth) {
   const { names, composite } = buildScanners(config, hasGitHubAuth);
   return { enabled: names, scanner: composite };
 }
+function withContextAck(task, contextAck) {
+  if (!contextAck) {
+    return task;
+  }
+  return {
+    ...task,
+    metadata: {
+      ...task.metadata,
+      contextAck
+    }
+  };
+}
 async function executeWithAgent(input2) {
   const startedAt = Date.now();
   const taskSlug = input2.task.id.replace(/[^a-zA-Z0-9-]/g, "-").replace(/-+/g, "-").slice(0, 30);
@@ -2053,10 +2419,10 @@ async function executeWithAgent(input2) {
 }
 async function commitSandboxChanges(sandboxPath, task, baseBranch) {
   try {
-    const statusResult = await execa2("git", ["status", "--porcelain"], { cwd: sandboxPath });
+    const statusResult = await execa3("git", ["status", "--porcelain"], { cwd: sandboxPath });
     if (statusResult.stdout.trim()) {
-      await execa2("git", ["add", "-A"], { cwd: sandboxPath });
-      await execa2(
+      await execa3("git", ["add", "-A"], { cwd: sandboxPath });
+      await execa3(
         "git",
         ["commit", "-m", `[OAC] ${task.title}
 
@@ -2064,11 +2430,9 @@ Automated contribution by OAC.`],
         { cwd: sandboxPath }
       );
     }
-    const diffResult = await execa2(
-      "git",
-      ["diff", "--name-only", `origin/${baseBranch}`, "HEAD"],
-      { cwd: sandboxPath }
-    );
+    const diffResult = await execa3("git", ["diff", "--name-only", `origin/${baseBranch}`, "HEAD"], {
+      cwd: sandboxPath
+    });
     const changedFiles = diffResult.stdout.trim().split("\n").filter(Boolean);
     return { hasChanges: changedFiles.length > 0, filesChanged: changedFiles };
   } catch {
@@ -2155,134 +2519,6 @@ function renderTaskResults(ui, taskResults) {
   }
 }
 
-// src/cli/commands/run/tracking.ts
-async function writeTracking(ctx, params) {
-  const { resolvedRepo, providerId, totalBudget, candidateTasks, completedTasks } = params;
-  const runDurationSeconds = (Date.now() - ctx.runStartedAt) / 1e3;
-  const contributionLog = buildContributionLog({
-    runId: ctx.runId,
-    repoFullName: resolvedRepo.fullName,
-    repoHeadSha: resolvedRepo.git.headSha,
-    defaultBranch: resolvedRepo.meta.defaultBranch,
-    repoOwner: resolvedRepo.owner,
-    providerId,
-    totalBudget,
-    runDurationSeconds,
-    discoveredTasks: candidateTasks.length,
-    taskResults: completedTasks
-  });
-  const trackingSpinner = createSpinner(ctx.suppressOutput, "Writing contribution log...");
-  try {
-    const logPath = await writeContributionLog(contributionLog, resolvedRepo.localPath);
-    trackingSpinner?.succeed(`Contribution log written: ${logPath}`);
-    return logPath;
-  } catch (error) {
-    trackingSpinner?.fail("Failed to write contribution log");
-    if (ctx.globalOptions.verbose && !ctx.suppressOutput) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.warn(ctx.ui.yellow(`[oac] Tracking failed: ${message}`));
-    }
-    return void 0;
-  }
-}
-function buildContributionLog(input2) {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const contributor = resolveGithubUsername(input2.repoOwner);
-  const contributionTasks = input2.taskResults.map((result) => ({
-    taskId: result.task.id,
-    title: result.task.title,
-    source: result.task.source,
-    complexity: result.task.complexity,
-    status: deriveTaskStatus(result.execution),
-    tokensUsed: Math.max(0, Math.floor(result.execution.totalTokensUsed)),
-    duration: Math.max(0, result.execution.duration),
-    filesChanged: result.execution.filesChanged,
-    pr: result.pr,
-    linkedIssue: result.task.linkedIssue ? {
-      number: result.task.linkedIssue.number,
-      url: result.task.linkedIssue.url
-    } : void 0,
-    error: result.execution.error
-  }));
-  const tasksSucceeded = contributionTasks.filter((task) => task.status !== "failed").length;
-  const tasksFailed = contributionTasks.length - tasksSucceeded;
-  const totalTokensUsed = contributionTasks.reduce((sum, task) => sum + task.tokensUsed, 0);
-  const totalFilesChanged = contributionTasks.reduce(
-    (sum, task) => sum + task.filesChanged.length,
-    0
-  );
-  return {
-    version: "1.0",
-    runId: input2.runId,
-    timestamp,
-    contributor: {
-      githubUsername: contributor,
-      email: process.env.GIT_AUTHOR_EMAIL ?? void 0
-    },
-    repo: {
-      fullName: input2.repoFullName,
-      headSha: input2.repoHeadSha,
-      defaultBranch: input2.defaultBranch
-    },
-    budget: {
-      provider: input2.providerId,
-      totalTokensBudgeted: input2.totalBudget,
-      totalTokensUsed
-    },
-    tasks: contributionTasks,
-    metrics: {
-      tasksDiscovered: input2.discoveredTasks,
-      tasksAttempted: contributionTasks.length,
-      tasksSucceeded,
-      tasksFailed,
-      totalDuration: Math.max(0, input2.runDurationSeconds),
-      totalFilesChanged,
-      totalLinesAdded: 0,
-      totalLinesRemoved: 0
-    }
-  };
-}
-function deriveTaskStatus(execution) {
-  if (execution.success) {
-    return "success";
-  }
-  if (execution.filesChanged.length > 0) {
-    return "partial";
-  }
-  return "failed";
-}
-function resolveGithubUsername(fallback) {
-  const candidates = [
-    process.env.GITHUB_USER,
-    process.env.GITHUB_USERNAME,
-    process.env.USER,
-    process.env.LOGNAME,
-    fallback,
-    "oac-user"
-  ];
-  for (const candidate of candidates) {
-    const normalized = sanitizeGithubUsername(candidate ?? "");
-    if (normalized) {
-      return normalized;
-    }
-  }
-  return "oac-user";
-}
-function sanitizeGithubUsername(value) {
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return null;
-  }
-  const cleaned = trimmed.replace(/[^A-Za-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
-  if (cleaned.length === 0 || cleaned.length > 39) {
-    return null;
-  }
-  if (!/^(?!-)[A-Za-z0-9-]+(?<!-)$/.test(cleaned)) {
-    return null;
-  }
-  return cleaned;
-}
-
 // src/cli/commands/run/epic.ts
 async function tryLoadOrAnalyzeEpics(ctx, params) {
   const { resolvedRepo, config, ghToken, contextDir, staleAfterMs } = params;
@@ -2342,8 +2578,8 @@ function makeStubEstimate(taskId, providerId, tokens) {
   };
 }
 async function executeEpicEntry(entry, params) {
-  const { adapter, resolvedRepo, providerId, timeoutSeconds, mode, ghToken } = params;
-  const task = epicAsTask(entry.epic);
+  const { adapter, resolvedRepo, providerId, timeoutSeconds, mode, ghToken, contextAck } = params;
+  const task = withContextAck2(epicAsTask(entry.epic), contextAck);
   const estimate = makeStubEstimate(task.id, providerId, entry.estimatedTokens);
   const result = await executeWithAgent({
     task,
@@ -2429,7 +2665,8 @@ async function runEpicPipeline(ctx, params) {
           providerId,
           timeoutSeconds,
           mode,
-          ghToken
+          ghToken,
+          contextAck: ctx.contextAck
         });
         epicCompletedCount += 1;
         if (executionSpinner) {
@@ -2557,22 +2794,32 @@ function renderEpicPlanTable(ui, plan, budget) {
     }
   }
 }
+function withContextAck2(task, contextAck) {
+  if (!contextAck) return task;
+  return {
+    ...task,
+    metadata: {
+      ...task.metadata,
+      contextAck
+    }
+  };
+}
 
 // src/cli/commands/run/retry.ts
-import { readFile as readFile5, readdir as readdir3 } from "fs/promises";
-import { resolve as resolve6 } from "path";
+import { readFile as readFile6, readdir as readdir4 } from "fs/promises";
+import { resolve as resolve8 } from "path";
 async function readMostRecentContributionLog(repoPath) {
-  const contributionsPath = resolve6(repoPath, ".oac", "contributions");
+  const contributionsPath = resolve8(repoPath, ".oac", "contributions");
   let entries;
   try {
-    const dirEntries = await readdir3(contributionsPath, { withFileTypes: true, encoding: "utf8" });
+    const dirEntries = await readdir4(contributionsPath, { withFileTypes: true, encoding: "utf8" });
     entries = dirEntries.filter((e) => e.isFile() && e.name.endsWith(".json")).map((e) => e.name).sort((a, b) => b.localeCompare(a));
   } catch {
     return void 0;
   }
   for (const fileName of entries) {
     try {
-      const content = await readFile5(resolve6(contributionsPath, fileName), "utf8");
+      const content = await readFile6(resolve8(contributionsPath, fileName), "utf8");
       const parsed = contributionLogSchema.safeParse(JSON.parse(content));
       if (parsed.success) return parsed.data;
     } catch {
@@ -2686,6 +2933,7 @@ async function runPipeline(options, globalOptions, ui) {
   const cloneSpinner = createSpinner(ctx.suppressOutput, "Preparing local clone...");
   await cloneRepo(resolvedRepo);
   cloneSpinner?.succeed(`Repository ready at ${resolvedRepo.localPath}`);
+  ctx.contextAck = await resolveContextAck(resolvedRepo.localPath, config, ui, ctx.suppressOutput);
   if (options.retryFailed) {
     const retryResults = await runRetryPipeline(ctx, {
       resolvedRepo,
@@ -3030,8 +3278,8 @@ function parseCsv(value) {
 }
 
 // src/cli/commands/status.ts
-import { readFile as readFile6 } from "fs/promises";
-import { resolve as resolve7 } from "path";
+import { readFile as readFile7 } from "fs/promises";
+import { resolve as resolve9 } from "path";
 import { Command as Command11 } from "commander";
 var WATCH_INTERVAL_MS = 2e3;
 function createStatusCommand() {
@@ -3070,9 +3318,9 @@ Examples:
   return command;
 }
 async function readRunStatus(repoPath) {
-  const statusPath = resolve7(repoPath, ".oac", "status.json");
+  const statusPath = resolve9(repoPath, ".oac", "status.json");
   try {
-    const raw = await readFile6(statusPath, "utf8");
+    const raw = await readFile7(statusPath, "utf8");
     const payload = JSON.parse(raw);
     return parseRunStatus(payload);
   } catch (error) {
@@ -3211,7 +3459,7 @@ function registerCommands(program) {
   program.addCommand(createExplainCommand());
 }
 async function createCliProgram() {
-  const version = true ? "2026.222.1" : "0.0.0";
+  const version = true ? "2026.222.2" : "0.0.0";
   const program = new Command12();
   program.name("oac").description("Open Agent Contribution CLI").version(version).option("--config <path>", "Config file path", "oac.config.ts").option("--verbose", "Enable verbose logging", false).option("--quiet", "Suppress non-error output", false).option("--json", "Output machine-readable JSON", false).option("--no-color", "Disable ANSI colors");
   registerCommands(program);
@@ -3233,4 +3481,4 @@ export {
   createCliProgram,
   runCli
 };
-//# sourceMappingURL=chunk-GPHH2IYN.js.map
+//# sourceMappingURL=chunk-ATVWSG75.js.map