@devory/core 0.1.1 → 0.3.1

package/dist/index.js

@@ -30,21 +30,156 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  ESCALATION_REASONS: () => ESCALATION_REASONS,
+  EXECUTION_POLICY_FILENAME: () => EXECUTION_POLICY_FILENAME,
+  EXECUTION_POLICY_VERSION: () => EXECUTION_POLICY_VERSION,
+  EXECUTION_POLICY_WORKSPACE_PATH: () => EXECUTION_POLICY_WORKSPACE_PATH,
+  HUMAN_INTERRUPTION_POLICY_FILENAME: () => HUMAN_INTERRUPTION_POLICY_FILENAME,
+  HUMAN_INTERRUPTION_POLICY_MAP: () => HUMAN_INTERRUPTION_POLICY_MAP,
+  HUMAN_INTERRUPTION_POLICY_VERSION: () => HUMAN_INTERRUPTION_POLICY_VERSION,
+  HUMAN_INTERRUPTION_POLICY_WORKSPACE_PATH: () => HUMAN_INTERRUPTION_POLICY_WORKSPACE_PATH,
+  HUMAN_QUESTION_ARTIFACT_DIR: () => HUMAN_QUESTION_ARTIFACT_DIR,
+  HUMAN_QUESTION_ARTIFACT_TYPE: () => HUMAN_QUESTION_ARTIFACT_TYPE,
+  HUMAN_QUESTION_DIGEST_ARTIFACT_DIR: () => HUMAN_QUESTION_DIGEST_ARTIFACT_DIR,
+  HUMAN_QUESTION_DIGEST_VERSION: () => HUMAN_QUESTION_DIGEST_VERSION,
+  HUMAN_QUESTION_EVENT_ARTIFACT_DIR: () => HUMAN_QUESTION_EVENT_ARTIFACT_DIR,
+  HUMAN_QUESTION_EVENT_VERSION: () => HUMAN_QUESTION_EVENT_VERSION,
+  HUMAN_QUESTION_VERSION: () => HUMAN_QUESTION_VERSION,
+  PLANNING_DRAFT_COMMIT_STATES: () => PLANNING_DRAFT_COMMIT_STATES,
+  PLANNING_DRAFT_CONTRACT_VERSION: () => PLANNING_DRAFT_CONTRACT_VERSION,
+  PLANNING_DRAFT_KINDS: () => PLANNING_DRAFT_KINDS,
+  PLANNING_DRAFT_PERSISTENCE_MODES: () => PLANNING_DRAFT_PERSISTENCE_MODES,
+  PLANNING_DRAFT_VALIDATION_STATUSES: () => PLANNING_DRAFT_VALIDATION_STATUSES,
+  PROGRESS_EVENT_CATEGORIES: () => PROGRESS_EVENT_CATEGORIES,
+  REQUIRED_FIELDS: () => REQUIRED_FIELDS,
+  RESUMABLE_RUN_STATUSES: () => RESUMABLE_RUN_STATUSES,
+  REVIEW_CONTROL_ACTIONS: () => REVIEW_CONTROL_ACTIONS,
+  REVIEW_CONTROL_CONTRACT_VERSION: () => REVIEW_CONTROL_CONTRACT_VERSION,
+  REVIEW_CONTROL_MECHANISMS: () => REVIEW_CONTROL_MECHANISMS,
+  REVIEW_QUEUE_ITEM_KINDS: () => REVIEW_QUEUE_ITEM_KINDS,
+  REVIEW_QUEUE_RUN_STATUSES: () => REVIEW_QUEUE_RUN_STATUSES,
+  REVIEW_QUEUE_TASK_STAGES: () => REVIEW_QUEUE_TASK_STAGES,
+  REVIEW_QUEUE_TRIAGE_STAGES: () => REVIEW_QUEUE_TRIAGE_STAGES,
+  ROUTING_DECISION_VERSION: () => ROUTING_DECISION_VERSION,
+  RUN_LEDGER_VERSION: () => RUN_LEDGER_VERSION,
+  SLACK_NOTIFICATION_CONFIG_VERSION: () => SLACK_NOTIFICATION_CONFIG_VERSION,
   STANDARDS_FILENAME: () => STANDARDS_FILENAME,
+  TASK_DRAFT_BODY_SECTION_ORDER: () => TASK_DRAFT_BODY_SECTION_ORDER,
+  TASK_DRAFT_COMMIT_STAGES: () => TASK_DRAFT_COMMIT_STAGES,
+  TASK_DRAFT_OPTIONAL_FRONTMATTER_FIELDS: () => TASK_DRAFT_OPTIONAL_FRONTMATTER_FIELDS,
+  TASK_DRAFT_RENDER_CONTRACT_VERSION: () => TASK_DRAFT_RENDER_CONTRACT_VERSION,
+  TASK_DRAFT_REQUIRED_FRONTMATTER_FIELDS: () => TASK_DRAFT_REQUIRED_FRONTMATTER_FIELDS,
+  TASK_MARKDOWN_FRONTMATTER_ORDER: () => TASK_MARKDOWN_FRONTMATTER_ORDER,
+  TASK_MARKDOWN_RENDERER_VERSION: () => TASK_MARKDOWN_RENDERER_VERSION,
+  TASK_MARKDOWN_SECTION_ORDER: () => TASK_MARKDOWN_SECTION_ORDER,
+  TASK_REVIEW_ACTIONS: () => TASK_REVIEW_ACTIONS,
+  TASK_REVIEW_ACTION_STAGE_MAP: () => TASK_REVIEW_ACTION_STAGE_MAP,
+  UNATTENDED_CHECKPOINT_TRIGGERS: () => UNATTENDED_CHECKPOINT_TRIGGERS,
+  UNATTENDED_CHECKPOINT_VERSION: () => UNATTENDED_CHECKPOINT_VERSION,
+  UNATTENDED_EXECUTION_CONTRACT_VERSION: () => UNATTENDED_EXECUTION_CONTRACT_VERSION,
+  UNATTENDED_RUN_STATUSES: () => UNATTENDED_RUN_STATUSES,
+  UNATTENDED_STALL_POLICY_FILENAME: () => UNATTENDED_STALL_POLICY_FILENAME,
+  UNATTENDED_STALL_POLICY_VERSION: () => UNATTENDED_STALL_POLICY_VERSION,
+  UNATTENDED_STALL_POLICY_WORKSPACE_PATH: () => UNATTENDED_STALL_POLICY_WORKSPACE_PATH,
+  VALID_HUMAN_NOTIFICATION_MODES: () => VALID_HUMAN_NOTIFICATION_MODES,
+  VALID_HUMAN_POLICY_THRESHOLD_KEYS: () => VALID_HUMAN_POLICY_THRESHOLD_KEYS,
+  VALID_POLICY_ESCALATION_BEHAVIORS: () => VALID_POLICY_ESCALATION_BEHAVIORS,
+  VALID_ROUTING_CONTEXT_INTENSITIES: () => VALID_ROUTING_CONTEXT_INTENSITIES,
+  VALID_ROUTING_EXECUTION_PROFILES: () => VALID_ROUTING_EXECUTION_PROFILES,
+  VALID_ROUTING_PRIORITY_LEVELS: () => VALID_ROUTING_PRIORITY_LEVELS,
+  VALID_SLACK_DELIVERY_MODES: () => VALID_SLACK_DELIVERY_MODES,
+  VALID_SLACK_DIGEST_GROUP_BY: () => VALID_SLACK_DIGEST_GROUP_BY,
+  VALID_SLACK_TRANSPORT_KINDS: () => VALID_SLACK_TRANSPORT_KINDS,
+  WORKER_HEALTH_STATUSES: () => WORKER_HEALTH_STATUSES,
+  applyExecutionPolicyOverrides: () => applyExecutionPolicyOverrides,
+  applyHumanInterruptionPolicyOverrides: () => applyHumanInterruptionPolicyOverrides,
+  applyTaskDraftValidation: () => applyTaskDraftValidation,
+  applyTaskRoutingOutcomeEvaluation: () => applyTaskRoutingOutcomeEvaluation,
+  applyUnattendedStallPolicyOverrides: () => applyUnattendedStallPolicyOverrides,
+  attachRoutingDecisionLinkage: () => attachRoutingDecisionLinkage,
+  buildEpicPlanningDraft: () => buildEpicPlanningDraft,
+  buildEpicPlanningDraftFixture: () => buildEpicPlanningDraftFixture,
+  buildExecutionPolicyInjection: () => buildExecutionPolicyInjection,
+  buildHumanQuestionArtifactRelativePath: () => buildHumanQuestionArtifactRelativePath,
+  buildHumanQuestionDigest: () => buildHumanQuestionDigest,
+  buildHumanQuestionDigestRelativePath: () => buildHumanQuestionDigestRelativePath,
+  buildHumanQuestionFixture: () => buildHumanQuestionFixture,
+  buildHumanQuestionLifecycleEvent: () => buildHumanQuestionLifecycleEvent,
+  buildHumanQuestionLifecycleEventRelativePath: () => buildHumanQuestionLifecycleEventRelativePath,
+  buildMinimalTaskDraftFixture: () => buildMinimalTaskDraftFixture,
+  buildPlanningDraftArtifactPath: () => buildPlanningDraftArtifactPath,
+  buildPlanningDraftStorageRelativePath: () => buildPlanningDraftStorageRelativePath,
+  buildRichTaskDraftFixture: () => buildRichTaskDraftFixture,
+  buildRoutingDecisionId: () => buildRoutingDecisionId,
+  buildRoutingOutcomeEvaluation: () => buildRoutingOutcomeEvaluation,
+  buildRunAttentionQueueItem: () => buildRunAttentionQueueItem,
+  buildTaskDraftRenderFixture: () => buildTaskDraftRenderFixture,
+  buildTaskDraftTargetPath: () => buildTaskDraftTargetPath,
+  buildTaskPlanningDraftFixture: () => buildTaskPlanningDraftFixture,
+  buildTaskReviewQueueItem: () => buildTaskReviewQueueItem,
+  buildTaskTriageQueueItem: () => buildTaskTriageQueueItem,
+  clearLicenseCache: () => clearLicenseCache,
+  clearLicenseToken: () => clearLicenseToken,
   detectTier: () => detectTier,
+  extractHumanQuestionArtifactMetadata: () => extractHumanQuestionArtifactMetadata,
   factoryPaths: () => factoryPaths,
   findFactoryContextDir: () => findFactoryContextDir,
+  getLicenseCacheFilePath: () => getLicenseCacheFilePath,
+  getLicenseFilePath: () => getLicenseFilePath,
+  getLicenseStatus: () => getLicenseStatus,
+  getSupportedReviewActions: () => getSupportedReviewActions,
+  getTaskHumanInterruptionPolicyOverrides: () => getTaskHumanInterruptionPolicyOverrides,
   isFeatureEnabled: () => isFeatureEnabled,
   loadBaseline: () => loadBaseline,
+  loadDefaultExecutionPolicy: () => loadDefaultExecutionPolicy,
+  loadDefaultHumanInterruptionPolicy: () => loadDefaultHumanInterruptionPolicy,
+  loadDefaultUnattendedStallPolicy: () => loadDefaultUnattendedStallPolicy,
   loadStandards: () => loadStandards,
+  loadWorkspaceExecutionPolicy: () => loadWorkspaceExecutionPolicy,
+  loadWorkspaceHumanInterruptionPolicy: () => loadWorkspaceHumanInterruptionPolicy,
+  loadWorkspaceUnattendedStallPolicy: () => loadWorkspaceUnattendedStallPolicy,
   mergeStandards: () => mergeStandards,
+  normalizeExecutionPolicyOverrides: () => normalizeExecutionPolicyOverrides,
+  normalizeHumanInterruptionPolicyOverrides: () => normalizeHumanInterruptionPolicyOverrides,
+  normalizePlanningDraft: () => normalizePlanningDraft,
+  normalizeReviewQueueItem: () => normalizeReviewQueueItem,
+  normalizeRoutingInput: () => normalizeRoutingInput,
+  normalizeRunRecord: () => normalizeRunRecord,
+  normalizeSlackNotificationConfig: () => normalizeSlackNotificationConfig,
+  normalizeTaskDraft: () => normalizeTaskDraft,
+  normalizeTaskRecord: () => normalizeTaskRecord,
+  normalizeUnattendedCheckpointArtifact: () => normalizeUnattendedCheckpointArtifact,
+  normalizeUnattendedExecutionSnapshot: () => normalizeUnattendedExecutionSnapshot,
+  normalizeUnattendedStallPolicyOverrides: () => normalizeUnattendedStallPolicyOverrides,
   parseFrontmatter: () => parseFrontmatter,
+  parseHumanQuestionArtifact: () => parseHumanQuestionArtifact,
+  parseHumanQuestionLifecycleEvent: () => parseHumanQuestionLifecycleEvent,
+  renderHumanQuestionDigestMarkdown: () => renderHumanQuestionDigestMarkdown,
+  renderTaskDraftMarkdown: () => renderTaskDraftMarkdown2,
+  renderTaskDraftTarget: () => renderTaskDraftTarget2,
+  renderTaskMarkdown: () => renderTaskDraftMarkdown,
+  renderTaskMarkdownTarget: () => renderTaskDraftTarget,
+  renderTaskPlanningDraftTarget: () => renderTaskPlanningDraftTarget,
   resolveBaselinePath: () => resolveBaselinePath,
+  resolveExecutionPolicy: () => resolveExecutionPolicy,
   resolveFactoryEnvironment: () => resolveFactoryEnvironment,
   resolveFactoryMode: () => resolveFactoryMode,
   resolveFactoryRoot: () => resolveFactoryRoot,
+  resolveHumanInterruptionPolicy: () => resolveHumanInterruptionPolicy,
+  resolveUnattendedStallPolicy: () => resolveUnattendedStallPolicy,
+  serializeHumanQuestionArtifact: () => serializeHumanQuestionArtifact,
+  serializeHumanQuestionDigest: () => serializeHumanQuestionDigest,
+  serializeHumanQuestionLifecycleEvent: () => serializeHumanQuestionLifecycleEvent,
+  serializePlanningDraft: () => serializePlanningDraft,
   serializeStandardsAsDoctrine: () => serializeStandardsAsDoctrine,
-  tierGateMessage: () => tierGateMessage
+  tierGateMessage: () => tierGateMessage,
+  toPlanningDraftValidationRecord: () => toPlanningDraftValidationRecord,
+  updateEpicPlanningDraft: () => updateEpicPlanningDraft,
+  validateTask: () => validateTask,
+  validateTaskBody: () => validateTaskBody,
+  validateTaskDraft: () => validateTaskDraft,
+  validateTaskMarkdown: () => validateTaskMarkdown,
+  writeLicenseToken: () => writeLicenseToken
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -83,71 +218,417 @@ function parseFrontmatter(content) {
   return { meta, body };
 }
 
-// src/factory-environment.ts
+// src/license.ts
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
-var FACTORY_MARKER = "FACTORY_CONTEXT.md";
-function trimEnv(value) {
-  if (typeof value !== "string")
+var crypto = __toESM(require("crypto"));
+var https = __toESM(require("https"));
+var ENV_VAR = "DEVORY_LICENSE_KEY";
+var LICENSE_FILE = path.join(".devory", "license");
+var LICENSE_CACHE_FILE = path.join(".devory", "license-cache.json");
+var KEY_CACHE_FILE = path.join(".devory", "key-cache.json");
+var LOCAL_JWK_FILE = path.join(".devory", "license.jwk");
+var KEYS_BASE_URL = "https://keys.devory.ai";
+var LICENSE_CACHE_TTL = 86400;
+var KEY_CACHE_TTL = 604800;
+var KEY_FETCH_TIMEOUT_MS = 5e3;
+function tokenHash(token) {
+  return crypto.createHash("sha256").update(token).digest("hex");
+}
+function b64urlToBuffer(s) {
+  return Buffer.from(s.replace(/-/g, "+").replace(/_/g, "/"), "base64");
+}
+function b64urlDecode(s) {
+  return b64urlToBuffer(s).toString("utf-8");
+}
+function parseJwt(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3) {
+    throw new Error("malformed JWT: expected header.payload.signature");
+  }
+  const [headerB64, payloadB64, sigB64] = parts;
+  let header;
+  let payload;
+  try {
+    header = JSON.parse(b64urlDecode(headerB64));
+    payload = JSON.parse(b64urlDecode(payloadB64));
+  } catch {
+    throw new Error("malformed JWT: could not JSON-parse header or payload");
+  }
+  if (!header.kid)
+    throw new Error("malformed JWT: missing kid in header");
+  if (header.alg !== "RS256")
+    throw new Error(`unsupported algorithm: ${header.alg ?? "(none)"}`);
+  if (!payload.sub)
+    throw new Error("malformed JWT: missing sub claim");
+  if (!payload.tier)
+    throw new Error("malformed JWT: missing tier claim");
+  if (typeof payload.exp !== "number")
+    throw new Error("malformed JWT: missing or invalid exp claim");
+  if (typeof payload.iat !== "number")
+    throw new Error("malformed JWT: missing or invalid iat claim");
+  return {
+    header,
+    payload,
+    signingInput: `${headerB64}.${payloadB64}`,
+    signatureBytes: b64urlToBuffer(sigB64)
+  };
+}
+function verifyRs256(signingInput, signatureBytes, jwk) {
+  try {
+    const key = crypto.createPublicKey({ key: jwk, format: "jwk" });
+    return crypto.verify("RSA-SHA256", Buffer.from(signingInput, "utf-8"), key, signatureBytes);
+  } catch {
+    return false;
+  }
+}
+function fetchKeyFromNetwork(kid) {
+  return new Promise((resolve2, reject) => {
+    const url = `${KEYS_BASE_URL}/${encodeURIComponent(kid)}`;
+    const req = https.get(url, { timeout: KEY_FETCH_TIMEOUT_MS }, (res) => {
+      if (res.statusCode !== 200) {
+        reject(new Error(`key fetch returned HTTP ${res.statusCode}`));
+        return;
+      }
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => {
+        try {
+          resolve2(JSON.parse(Buffer.concat(chunks).toString("utf-8")));
+        } catch {
+          reject(new Error("key fetch returned invalid JSON"));
+        }
+      });
+    });
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error(`key fetch timed out after ${KEY_FETCH_TIMEOUT_MS} ms`));
+    });
+    req.on("error", reject);
+  });
+}
+function readKeyFromCache(kid, factoryRoot) {
+  const cachePath = path.join(factoryRoot, KEY_CACHE_FILE);
+  if (!fs.existsSync(cachePath))
     return null;
-  const trimmed = value.trim();
-  return trimmed === "" ? null : trimmed;
+  try {
+    const cache = JSON.parse(fs.readFileSync(cachePath, "utf-8"));
+    const entry = cache[kid];
+    if (!entry)
+      return null;
+    if (Math.floor(Date.now() / 1e3) >= entry.cached_at + KEY_CACHE_TTL)
+      return null;
+    return entry.jwk;
+  } catch {
+    return null;
+  }
 }
-function findFactoryContextDir(startDir) {
-  let current = path.resolve(startDir);
-  while (true) {
-    if (fs.existsSync(path.join(current, FACTORY_MARKER))) {
-      return current;
+function writeKeyToCache(kid, jwk, factoryRoot) {
+  try {
+    const cachePath = path.join(factoryRoot, KEY_CACHE_FILE);
+    let cache = {};
+    if (fs.existsSync(cachePath)) {
+      try {
+        cache = JSON.parse(fs.readFileSync(cachePath, "utf-8"));
+      } catch {
+      }
     }
-    const parent = path.dirname(current);
-    if (parent === current) {
+    cache[kid] = { jwk, cached_at: Math.floor(Date.now() / 1e3) };
+    fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+    fs.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
+  } catch {
+  }
+}
+async function resolvePublicKey(kid, factoryRoot) {
+  if (factoryRoot) {
+    const localPath = path.join(factoryRoot, LOCAL_JWK_FILE);
+    if (fs.existsSync(localPath)) {
+      try {
+        const jwk2 = JSON.parse(fs.readFileSync(localPath, "utf-8"));
+        if (!jwk2.kid || jwk2.kid === kid)
+          return jwk2;
+      } catch {
+      }
+    }
+    const cached = readKeyFromCache(kid, factoryRoot);
+    if (cached)
+      return cached;
+  }
+  const jwk = await fetchKeyFromNetwork(kid);
+  if (factoryRoot)
+    writeKeyToCache(kid, jwk, factoryRoot);
+  return jwk;
+}
+function readLicenseCache(factoryRoot, token) {
+  const cachePath = path.join(factoryRoot, LICENSE_CACHE_FILE);
+  if (!fs.existsSync(cachePath))
+    return null;
+  try {
+    const cache = JSON.parse(fs.readFileSync(cachePath, "utf-8"));
+    const now = Math.floor(Date.now() / 1e3);
+    if (!cache.token_hash || cache.token_hash !== tokenHash(token))
       return null;
+    if (now < cache.cache_until && now < cache.exp)
+      return cache;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function tierFromClaim(tierClaim) {
+  if (tierClaim === "pro" || tierClaim === "pro_annual" || tierClaim === "lifetime")
+    return "pro";
+  if (tierClaim === "teams" || tierClaim === "teams_annual")
+    return "teams";
+  return "core";
+}
+function writeLicenseCache(factoryRoot, payload, kid) {
+  try {
+    const now = Math.floor(Date.now() / 1e3);
+    const { token } = resolveToken(factoryRoot);
+    if (!token)
+      return;
+    const cache = {
+      kid,
+      sub: payload.sub,
+      tier: tierFromClaim(payload.tier),
+      exp: payload.exp,
+      token_hash: tokenHash(token),
+      verified_at: now,
+      cache_until: now + LICENSE_CACHE_TTL
+    };
+    if (payload.org)
+      cache.org_id = payload.org;
+    if (payload.seats != null)
+      cache.seat_count = payload.seats;
+    const cachePath = path.join(factoryRoot, LICENSE_CACHE_FILE);
+    fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+    fs.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
+  } catch {
+  }
+}
+function resolveToken(factoryRoot) {
+  const envVal = process.env[ENV_VAR];
+  if (envVal !== void 0) {
+    return { token: envVal.trim() || null, source: "env" };
+  }
+  if (factoryRoot) {
+    const filePath = path.join(factoryRoot, LICENSE_FILE);
+    if (fs.existsSync(filePath)) {
+      const token = fs.readFileSync(filePath, "utf-8").trim();
+      return { token: token || null, source: "file", licenseFilePath: filePath };
     }
-    current = parent;
   }
+  return { token: null, source: void 0 };
 }
-function resolveFactoryRoot(startDir = process.cwd()) {
-  const explicit = trimEnv(process.env.DEVORY_FACTORY_ROOT);
-  if (explicit) {
-    return { root: explicit, source: "env:DEVORY_FACTORY_ROOT" };
+function getLicenseFilePath(factoryRoot) {
+  return path.join(factoryRoot, LICENSE_FILE);
+}
+function getLicenseCacheFilePath(factoryRoot) {
+  return path.join(factoryRoot, LICENSE_CACHE_FILE);
+}
+function writeLicenseToken(factoryRoot, token) {
+  const trimmed = token.trim();
+  if (!trimmed) {
+    throw new Error("License key cannot be empty");
   }
-  const legacy = trimEnv(process.env.FACTORY_ROOT);
-  if (legacy) {
-    return { root: legacy, source: "env:FACTORY_ROOT" };
+  const licensePath = getLicenseFilePath(factoryRoot);
+  fs.mkdirSync(path.dirname(licensePath), { recursive: true });
+  fs.writeFileSync(licensePath, `${trimmed}
+`, { mode: 384 });
+  clearLicenseCache(factoryRoot);
+  return { path: licensePath };
+}
+function clearLicenseToken(factoryRoot) {
+  const licensePath = getLicenseFilePath(factoryRoot);
+  const removed = fs.existsSync(licensePath);
+  if (removed) {
+    fs.unlinkSync(licensePath);
   }
-  const walked = findFactoryContextDir(startDir);
-  if (walked) {
-    return { root: walked, source: "git-walk" };
+  clearLicenseCache(factoryRoot);
+  return { path: licensePath, removed };
+}
+function clearLicenseCache(factoryRoot) {
+  const cachePath = getLicenseCacheFilePath(factoryRoot);
+  if (fs.existsSync(cachePath)) {
+    fs.unlinkSync(cachePath);
   }
-  return { root: path.resolve(startDir), source: "cwd" };
 }
-function factoryPaths(root) {
+async function getLicenseStatus(factoryRoot) {
+  const { token, source, licenseFilePath } = resolveToken(factoryRoot);
+  const cacheFilePath = factoryRoot ? getLicenseCacheFilePath(factoryRoot) : void 0;
+  const sourceLabel = source === "env" ? ENV_VAR : source === "file" ? ".devory/license" : void 0;
+  if (!token) {
+    return {
+      tier: "core",
+      reason: "No license key found \u2014 running on Core tier",
+      hasKey: false,
+      source,
+      sourceLabel,
+      envVarName: ENV_VAR,
+      licenseFilePath,
+      cacheFilePath,
+      cacheUsed: false,
+      fallbackToCore: false
+    };
+  }
+  if (factoryRoot) {
+    const cached = readLicenseCache(factoryRoot, token);
+    if (cached) {
+      return {
+        tier: cached.tier,
+        hasKey: true,
+        key: token,
+        source,
+        sourceLabel,
+        envVarName: ENV_VAR,
+        licenseFilePath,
+        cacheFilePath,
+        cacheUsed: true,
+        fallbackToCore: false,
+        userId: cached.sub,
+        kid: cached.kid,
+        expiresAt: new Date(cached.exp * 1e3).toISOString(),
+        orgId: cached.org_id,
+        seatCount: cached.seat_count,
+        reason: `License verified from cache (user: ${cached.sub}, expires: ${new Date(cached.exp * 1e3).toISOString().slice(0, 10)})`
+      };
+    }
+  }
+  let parsed;
+  try {
+    parsed = parseJwt(token);
+  } catch (err) {
+    return {
+      tier: "core",
+      hasKey: true,
+      key: token,
+      source,
+      sourceLabel,
+      envVarName: ENV_VAR,
+      licenseFilePath,
+      cacheFilePath,
+      cacheUsed: false,
+      fallbackToCore: true,
+      invalid: true,
+      reason: `License token is malformed: ${err instanceof Error ? err.message : String(err)} \u2014 falling back to Core tier`
+    };
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  if (now >= parsed.payload.exp) {
+    return {
+      tier: "core",
+      hasKey: true,
+      key: token,
+      source,
+      sourceLabel,
+      envVarName: ENV_VAR,
+      licenseFilePath,
+      cacheFilePath,
+      cacheUsed: false,
+      fallbackToCore: true,
+      invalid: true,
+      expiresAt: new Date(parsed.payload.exp * 1e3).toISOString(),
+      kid: parsed.header.kid,
+      reason: "License token has expired \u2014 please renew your license"
+    };
+  }
+  let jwk;
+  try {
+    jwk = await resolvePublicKey(parsed.header.kid, factoryRoot);
+  } catch (err) {
+    return {
+      tier: "core",
+      hasKey: true,
+      key: token,
+      source,
+      sourceLabel,
+      envVarName: ENV_VAR,
+      licenseFilePath,
+      cacheFilePath,
+      cacheUsed: false,
+      fallbackToCore: true,
+      invalid: true,
+      expiresAt: new Date(parsed.payload.exp * 1e3).toISOString(),
+      kid: parsed.header.kid,
+      reason: `Could not resolve public key for kid "${parsed.header.kid}": ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  if (!verifyRs256(parsed.signingInput, parsed.signatureBytes, jwk)) {
+    return {
+      tier: "core",
+      hasKey: true,
+      key: token,
+      source,
+      sourceLabel,
+      envVarName: ENV_VAR,
+      licenseFilePath,
+      cacheFilePath,
+      cacheUsed: false,
+      fallbackToCore: true,
+      invalid: true,
+      expiresAt: new Date(parsed.payload.exp * 1e3).toISOString(),
+      kid: parsed.header.kid,
+      reason: "License token signature is invalid \u2014 token may have been tampered with"
+    };
+  }
+  if (factoryRoot) {
+    writeLicenseCache(factoryRoot, parsed.payload, parsed.header.kid);
+  }
+  const tier = tierFromClaim(parsed.payload.tier);
+  const tierLabel = tier === "teams" ? "Teams" : "Pro";
+  const result = {
+    tier,
+    hasKey: true,
+    key: token,
+    source,
+    sourceLabel,
+    envVarName: ENV_VAR,
+    licenseFilePath,
+    cacheFilePath,
+    cacheUsed: false,
+    fallbackToCore: false,
+    userId: parsed.payload.sub,
+    expiresAt: new Date(parsed.payload.exp * 1e3).toISOString(),
+    kid: parsed.header.kid,
+    reason: `Valid ${tierLabel} license (user: ${parsed.payload.sub}, expires: ${new Date(parsed.payload.exp * 1e3).toISOString().slice(0, 10)})`
+  };
+  if (parsed.payload.org)
+    result.orgId = parsed.payload.org;
+  if (parsed.payload.seats != null)
+    result.seatCount = parsed.payload.seats;
+  return result;
+}
+async function detectTier(factoryRoot) {
+  const status = await getLicenseStatus(factoryRoot);
   return {
-    tasksDir: path.join(root, "tasks"),
-    runsDir: path.join(root, "runs"),
-    artifactsDir: path.join(root, "artifacts"),
-    contextFile: path.join(root, FACTORY_MARKER)
+    tier: status.tier,
+    key: status.key,
+    source: status.source,
+    invalid: status.invalid,
+    reason: status.reason,
+    userId: status.userId,
+    orgId: status.orgId,
+    seatCount: status.seatCount
   };
 }
-function resolveFactoryMode(env = process.env) {
-  const explicitMode = trimEnv(env.DEVORY_FACTORY_MODE) ?? trimEnv(env.FACTORY_MODE);
-  if (explicitMode === "hosted")
-    return "hosted";
-  if (explicitMode === "local")
-    return "local";
-  if (trimEnv(env.DEVORY_REMOTE_FACTORY_URL) || trimEnv(env.FACTORY_REMOTE_URL)) {
-    return "hosted";
+function isFeatureEnabled(feature, info) {
+  switch (feature) {
+    case "custom_rules":
+    case "baseline_overrides":
+    case "shared_doctrine":
+    case "pr_gates":
+      return info.tier === "pro" || info.tier === "teams";
   }
-  return "local";
 }
-function resolveFactoryEnvironment(startDir = process.cwd(), env = process.env) {
-  const { root, source } = resolveFactoryRoot(startDir);
-  return {
-    root,
-    source,
-    mode: resolveFactoryMode(env),
-    paths: factoryPaths(root)
+function tierGateMessage(feature) {
+  const featureLabel = {
+    custom_rules: "custom_rules in devory.standards.yml",
+    baseline_overrides: "baseline overrides",
+    shared_doctrine: "shared doctrine",
+    pr_gates: "PR gates"
   };
+  return `[devory] ${featureLabel[feature]} requires a Pro or Teams license \u2014 set DEVORY_LICENSE_KEY or create .devory/license to upgrade. This setting will be ignored on Core tier.`;
 }
 
 // src/standards.ts
@@ -2817,8 +3298,7 @@ var safeDump = renamed("safeDump", "dump");
 
 // src/standards.ts
 var import_meta = {};
-var __filename = (0, import_url.fileURLToPath)(import_meta.url);
-var __dirname = path2.dirname(__filename);
+var MODULE_DIR = typeof __dirname === "string" ? __dirname : path2.dirname((0, import_url.fileURLToPath)(import_meta.url));
 var STANDARDS_FILENAME = "devory.standards.yml";
 function loadStandards(factoryRoot) {
   const filePath = path2.join(factoryRoot, STANDARDS_FILENAME);
@@ -2846,7 +3326,7 @@ function loadStandards(factoryRoot) {
   };
 }
 var DEVORY_DEFAULTS_PREFIX = "@devory/defaults/";
-var DEFAULTS_DIR = path2.join(__dirname, "defaults");
+var DEFAULTS_DIR = path2.join(MODULE_DIR, "defaults");
 var KNOWN_BASELINES = {
   generic: "generic.yml",
   "typescript-nextjs": "typescript-nextjs.yml",
@@ -2953,81 +3433,2971 @@ function serializeStandardsAsDoctrine(standards) {
   return lines.join("\n").trimEnd();
 }
 
-// src/license.ts
+// src/factory-environment.ts
 var fs3 = __toESM(require("fs"));
 var path3 = __toESM(require("path"));
-var ENV_VAR = "DEVORY_LICENSE_KEY";
-var LICENSE_FILE = path3.join(".devory", "license");
-var MIN_KEY_LENGTH = 16;
-function detectTier(factoryRoot) {
-  const envKey = process.env[ENV_VAR];
-  if (envKey !== void 0) {
-    return validateKey(envKey.trim(), "env");
-  }
-  if (factoryRoot) {
-    const filePath = path3.join(factoryRoot, LICENSE_FILE);
-    if (fs3.existsSync(filePath)) {
-      const fileKey = fs3.readFileSync(filePath, "utf-8").trim();
-      return validateKey(fileKey, "file");
+var FACTORY_MARKER = "FACTORY_CONTEXT.md";
+function trimEnv(value) {
+  if (typeof value !== "string")
+    return null;
+  const trimmed = value.trim();
+  return trimmed === "" ? null : trimmed;
+}
+function findFactoryContextDir(startDir) {
+  let current = path3.resolve(startDir);
+  while (true) {
+    if (fs3.existsSync(path3.join(current, FACTORY_MARKER))) {
+      return current;
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) {
+      return null;
     }
+    current = parent;
+  }
+}
+function resolveFactoryRoot(startDir = process.cwd()) {
+  const explicit = trimEnv(process.env.DEVORY_FACTORY_ROOT);
+  if (explicit) {
+    return { root: explicit, source: "env:DEVORY_FACTORY_ROOT" };
+  }
+  const legacy = trimEnv(process.env.FACTORY_ROOT);
+  if (legacy) {
+    return { root: legacy, source: "env:FACTORY_ROOT" };
+  }
+  const walked = findFactoryContextDir(startDir);
+  if (walked) {
+    return { root: walked, source: "git-walk" };
   }
+  return { root: path3.resolve(startDir), source: "cwd" };
+}
+function factoryPaths(root) {
   return {
-    tier: "core",
-    reason: "No license key found \u2014 running on Core tier"
+    tasksDir: path3.join(root, "tasks"),
+    runsDir: path3.join(root, "runs"),
+    artifactsDir: path3.join(root, "artifacts"),
+    contextFile: path3.join(root, FACTORY_MARKER)
   };
 }
-function validateKey(key, source) {
-  if (!key || key.length < MIN_KEY_LENGTH) {
-    return {
-      tier: "core",
-      key,
-      source,
-      invalid: true,
-      reason: `License key from ${source === "env" ? "DEVORY_LICENSE_KEY" : ".devory/license"} is invalid (must be \u2265 ${MIN_KEY_LENGTH} characters) \u2014 falling back to Core tier`
-    };
+function resolveFactoryMode(env = process.env) {
+  const explicitMode = trimEnv(env.DEVORY_FACTORY_MODE) ?? trimEnv(env.FACTORY_MODE);
+  if (explicitMode === "hosted")
+    return "hosted";
+  if (explicitMode === "local")
+    return "local";
+  if (trimEnv(env.DEVORY_REMOTE_FACTORY_URL) || trimEnv(env.FACTORY_REMOTE_URL)) {
+    return "hosted";
   }
+  return "local";
+}
+function resolveFactoryEnvironment(startDir = process.cwd(), env = process.env) {
+  const { root, source } = resolveFactoryRoot(startDir);
   return {
-    tier: "pro",
-    key,
+    root,
     source,
-    reason: `License key found via ${source === "env" ? "DEVORY_LICENSE_KEY" : ".devory/license"} \u2014 Pro tier active`
+    mode: resolveFactoryMode(env),
+    paths: factoryPaths(root)
   };
 }
-function isFeatureEnabled(feature, info) {
-  switch (feature) {
-    case "custom_rules":
-    case "baseline_overrides":
-    case "shared_doctrine":
-    case "pr_gates":
-      return info.tier === "pro";
-  }
+
+// src/unattended-execution.ts
+var UNATTENDED_EXECUTION_CONTRACT_VERSION = "unattended-execution-v1";
+var UNATTENDED_RUN_STATUSES = [
+  "starting",
+  "active",
+  "waiting_on_tool",
+  "waiting_on_model",
+  "checkpointing",
+  "stalled",
+  "blocked_on_human",
+  "failed",
+  "completed",
+  "cancelled"
+];
+var WORKER_HEALTH_STATUSES = [
+  "healthy",
+  "lagging",
+  "stalled",
+  "recovering",
+  "offline"
+];
+var PROGRESS_EVENT_CATEGORIES = [
+  "session_started",
+  "tool_activity",
+  "file_mutation",
+  "test_activity",
+  "checkpoint_write",
+  "compaction",
+  "retry",
+  "failover",
+  "escalation",
+  "status"
+];
+var ESCALATION_REASONS = [
+  "policy_blocked",
+  "checkpoint_unavailable",
+  "retry_exhausted",
+  "stall_detected",
+  "human_required",
+  "fatal_error"
+];
+function asObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function tierGateMessage(feature) {
-  const featureLabel = {
-    custom_rules: "custom_rules in devory.standards.yml",
-    baseline_overrides: "baseline overrides",
-    shared_doctrine: "shared doctrine",
-    pr_gates: "PR gates"
+function asString(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function asNullableString(value) {
+  return typeof value === "string" ? value : null;
+}
+function asNullableNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asNumber(value, fallback = 0) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function asBoolean(value, fallback = false) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function normalizeProgressCategory(value) {
+  return typeof value === "string" && PROGRESS_EVENT_CATEGORIES.includes(value) ? value : null;
+}
+function normalizeUnattendedStatus(value) {
+  return typeof value === "string" && UNATTENDED_RUN_STATUSES.includes(value) ? value : "starting";
+}
+function normalizeWorkerHealth(value) {
+  return typeof value === "string" && WORKER_HEALTH_STATUSES.includes(value) ? value : "healthy";
+}
+function normalizeEscalationReason(value) {
+  return typeof value === "string" && ESCALATION_REASONS.includes(value) ? value : null;
+}
+function normalizeHeartbeat(value) {
+  const record = asObject(value);
+  return {
+    captured_at: asNullableString(record?.captured_at),
+    age_ms: asNullableNumber(record?.age_ms),
+    progress_sequence: asNullableNumber(record?.progress_sequence),
+    active_task_id: asNullableString(record?.active_task_id),
+    lane_id: asNullableString(record?.lane_id),
+    tool_name: asNullableString(record?.tool_name),
+    adapter_session_id: asNullableString(record?.adapter_session_id)
+  };
+}
+function normalizeProgressPointer(value) {
+  const record = asObject(value);
+  return {
+    latest_event_id: asNullableString(record?.latest_event_id),
+    latest_event_at: asNullableString(record?.latest_event_at),
+    sequence: asNullableNumber(record?.sequence),
+    category: normalizeProgressCategory(record?.category),
+    summary: asNullableString(record?.summary)
+  };
+}
+function normalizeCheckpoint(value) {
+  const record = asObject(value);
+  return {
+    artifact_path: asNullableString(record?.artifact_path),
+    checkpoint_id: asNullableString(record?.checkpoint_id),
+    captured_at: asNullableString(record?.captured_at),
+    source_run_id: asNullableString(record?.source_run_id),
+    resumed_from_run_id: asNullableString(record?.resumed_from_run_id)
+  };
+}
+function normalizeRecovery(value) {
+  const record = asObject(value);
+  const state = record?.state === "not_attempted" || record?.state === "succeeded" || record?.state === "failed" ? record.state : "not_attempted";
+  return {
+    state,
+    attempts: asNumber(record?.attempts, 0),
+    last_attempt_at: asNullableString(record?.last_attempt_at),
+    resumed_run_id: asNullableString(record?.resumed_run_id),
+    failover_run_id: asNullableString(record?.failover_run_id),
+    reason: asNullableString(record?.reason)
+  };
+}
+function normalizeEscalation(value) {
+  const record = asObject(value);
+  return {
+    required: asBoolean(record?.required),
+    reason: normalizeEscalationReason(record?.reason),
+    summary: asNullableString(record?.summary),
+    triggered_at: asNullableString(record?.triggered_at)
+  };
+}
+function normalizeUnattendedExecutionSnapshot(value) {
+  const record = asObject(value);
+  if (!record)
+    return null;
+  const runId = asString(record.run_id);
+  if (!runId)
+    return null;
+  const durableSource = record.durable_source === "artifact" ? "artifact" : "run_record";
+  return {
+    version: UNATTENDED_EXECUTION_CONTRACT_VERSION,
+    run_id: runId,
+    status: normalizeUnattendedStatus(record.status),
+    worker_health: normalizeWorkerHealth(record.worker_health),
+    durable_source: durableSource,
+    transient_adapter_state: asNullableString(record.transient_adapter_state),
+    heartbeat: normalizeHeartbeat(record.heartbeat),
+    progress: normalizeProgressPointer(record.progress),
+    checkpoint: normalizeCheckpoint(record.checkpoint),
+    recovery: normalizeRecovery(record.recovery),
+    escalation: normalizeEscalation(record.escalation)
+  };
+}
+
+// src/run-ledger.ts
+var RUN_LEDGER_VERSION = "routing-evidence-v1";
+var RESUMABLE_RUN_STATUSES = [
+  "failed",
+  "paused_for_review"
+];
+function asObject2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asString2(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function asNullableString2(value) {
+  return typeof value === "string" ? value : null;
+}
+function asStringArray(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function asBoolean2(value, fallback = false) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function asNullableNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asNumber2(value, fallback = 0) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function normalizeFailureRecord(value) {
+  const record = asObject2(value);
+  if (!record)
+    return null;
+  const taskId = asString2(record.task_id);
+  const reason = asString2(record.reason);
+  const timestamp2 = asString2(record.timestamp);
+  if (!taskId || !reason || !timestamp2)
+    return null;
+  return {
+    task_id: taskId,
+    reason,
+    timestamp: timestamp2
+  };
+}
+function normalizeCostEventRecord(value) {
+  const record = asObject2(value);
+  if (!record)
+    return null;
+  const status = record.status === "warn" || record.status === "block" ? record.status : null;
+  const taskId = asString2(record.task_id);
+  const timestamp2 = asString2(record.timestamp);
+  if (!status || !taskId || !timestamp2)
+    return null;
+  return {
+    task_id: taskId,
+    model_id: asNullableString2(record.model_id),
+    status,
+    reasons: asStringArray(record.reasons),
+    spend_units: asNumber2(record.spend_units, 0),
+    timestamp: timestamp2
+  };
+}
+function normalizeProgressEventRecord(value) {
+  const record = asObject2(value);
+  if (!record)
+    return null;
+  const eventId = asString2(record.event_id);
+  const sequence = asNumber2(record.sequence, Number.NaN);
+  const createdAt = asString2(record.created_at);
+  const summary = asString2(record.summary);
+  const category = typeof record.category === "string" && PROGRESS_EVENT_CATEGORIES.includes(record.category) ? record.category : null;
+  const status = typeof record.status === "string" && UNATTENDED_RUN_STATUSES.includes(record.status) ? record.status : null;
+  if (!eventId || !Number.isFinite(sequence) || !createdAt || !summary || !category) {
+    return null;
+  }
+  return {
+    event_id: eventId,
+    sequence,
+    category,
+    status,
+    task_id: asNullableString2(record.task_id),
+    created_at: createdAt,
+    summary,
+    details: asStringArray(record.details)
+  };
+}
+function normalizeTaskBlockState(value) {
+  const record = asObject2(value);
+  if (!record)
+    return null;
+  const kind = record.kind === "human-question" || record.kind === "execution-failure" || record.kind === "dependency-wait" ? record.kind : null;
+  const interruptionLevel = record.interruption_level === "level_1" || record.interruption_level === "level_2" || record.interruption_level === "level_3" ? record.interruption_level : null;
+  const fallbackBehavior = record.fallback_behavior === "continue-other-work" || record.fallback_behavior === "pause-affected-lane" || record.fallback_behavior === "halt-run" || record.fallback_behavior === "assume-default" || record.fallback_behavior === "skip-task" ? record.fallback_behavior : null;
+  return {
+    kind,
+    question_id: asNullableString2(record.question_id),
+    dependency_task_id: asNullableString2(record.dependency_task_id),
+    reason: asNullableString2(record.reason),
+    since: asNullableString2(record.since),
+    interruption_level: interruptionLevel,
+    fallback_behavior: fallbackBehavior
+  };
+}
+function normalizeRunInterruptionState(value) {
+  const record = asObject2(value);
+  if (!record)
+    return null;
+  const interruptionLevel = record.interruption_level === "level_1" || record.interruption_level === "level_2" || record.interruption_level === "level_3" ? record.interruption_level : null;
+  const fallbackBehavior = record.fallback_behavior === "continue-other-work" || record.fallback_behavior === "pause-affected-lane" || record.fallback_behavior === "halt-run" || record.fallback_behavior === "assume-default" || record.fallback_behavior === "skip-task" ? record.fallback_behavior : null;
+  const runDisposition = record.run_disposition === "continue" || record.run_disposition === "pause" || record.run_disposition === "halt" ? record.run_disposition : null;
+  const laneState = record.lane_state === "running" || record.lane_state === "paused" ? record.lane_state : null;
+  return {
+    active: asBoolean2(record.active),
+    question_id: asNullableString2(record.question_id),
+    blocking_task_id: asNullableString2(record.blocking_task_id),
+    lane_id: asNullableString2(record.lane_id),
+    interruption_level: interruptionLevel,
+    fallback_behavior: fallbackBehavior,
+    run_disposition: runDisposition,
+    lane_state: laneState,
+    updated_at: asNullableString2(record.updated_at)
+  };
+}
+function buildRoutingEvidence(record) {
+  const existing = asObject2(record.routing_evidence);
+  const decision = asObject2(existing?.routing_decision);
+  const selection = asObject2(existing?.selection);
+  const fallback = asObject2(existing?.fallback);
+  const retries = asObject2(existing?.retries);
+  const timing = asObject2(existing?.timing);
+  const usage = asObject2(existing?.usage);
+  const outcome = asObject2(existing?.outcome);
+  const inputSnapshot = asObject2(existing?.input_snapshot);
+  const normalizedInput = inputSnapshot?.normalized_input && typeof inputSnapshot.normalized_input === "object" ? inputSnapshot.normalized_input : null;
+  const routingDecision = decision && typeof decision === "object" ? decision : null;
+  const selectedEngine = asNullableString2(selection?.selected_engine) ?? asString2(record.engine);
+  const selectedModel = asNullableString2(selection?.selected_model) ?? asNullableString2(record.model_id);
+  const fallbackTaken = asBoolean2(fallback?.taken, asBoolean2(record.fallback_taken));
+  const spendUnits = asNullableNumber2(usage?.spend_units) ?? asNullableNumber2(record.spend_units);
+  const costTier = asNullableString2(usage?.cost_tier) ?? asNullableString2(record.cost_tier);
+  const outcomeLabel = asNullableString2(outcome?.outcome_label) ?? asString2(record.outcome);
+  return {
+    routing_decision: routingDecision,
+    requested_role: asNullableString2(existing?.requested_role),
+    input_snapshot: {
+      routing_decision_id: asNullableString2(inputSnapshot?.routing_decision_id) ?? asNullableString2(asObject2(routingDecision?.linkage)?.decision_id),
+      related_routing_decision_ids: asStringArray(inputSnapshot?.related_routing_decision_ids),
+      requested_role: asNullableString2(inputSnapshot?.requested_role),
+      requested_engine: asNullableString2(inputSnapshot?.requested_engine),
+      requested_pipeline: asNullableString2(inputSnapshot?.requested_pipeline),
+      task_branch: asNullableString2(inputSnapshot?.task_branch),
+      normalized_summary: asNullableString2(inputSnapshot?.normalized_summary),
+      normalized_input: normalizedInput
+    },
+    selection: {
+      selected_engine: selectedEngine || asNullableString2(routingDecision?.engine) || null,
+      selected_provider: asNullableString2(selection?.selected_provider) ?? asNullableString2(routingDecision?.provider),
+      selected_model: selectedModel ?? asNullableString2(routingDecision?.model_id),
+      rationale: asStringArray(selection?.rationale).length > 0 ? asStringArray(selection?.rationale) : asStringArray(routingDecision?.rationale)
+    },
+    fallback: {
+      taken: fallbackTaken,
+      reason: asNullableString2(fallback?.reason) ?? (asStringArray(asObject2(routingDecision?.fallback_path)?.reasons)[0] ?? null),
+      attempted_path: asStringArray(fallback?.attempted_path).length > 0 ? asStringArray(fallback?.attempted_path) : asStringArray(asObject2(routingDecision?.fallback_path)?.candidate_model_ids)
+    },
+    retries: {
+      attempts: asNumber2(retries?.attempts, 0),
+      resumed_from_run_id: asNullableString2(retries?.resumed_from_run_id),
+      history: asStringArray(retries?.history)
+    },
+    timing: {
+      queued_at: asNullableString2(timing?.queued_at),
+      routing_started_at: asNullableString2(timing?.routing_started_at),
+      routing_completed_at: asNullableString2(timing?.routing_completed_at),
+      execution_started_at: asNullableString2(timing?.execution_started_at) ?? asString2(record.start_time),
+      execution_completed_at: asNullableString2(timing?.execution_completed_at) ?? asString2(record.end_time)
+    },
+    usage: {
+      prompt_tokens: asNullableNumber2(usage?.prompt_tokens),
+      completion_tokens: asNullableNumber2(usage?.completion_tokens),
+      total_tokens: asNullableNumber2(usage?.total_tokens),
+      spend_units: spendUnits,
+      estimated_cost_usd: asNullableNumber2(usage?.estimated_cost_usd),
+      cost_tier: costTier
+    },
+    outcome: {
+      final_stage: asNullableString2(outcome?.final_stage),
+      verification_state: asNullableString2(outcome?.verification_state),
+      outcome_label: outcomeLabel || null,
+      operator_summary: asNullableString2(outcome?.operator_summary),
+      evaluation: outcome?.evaluation && typeof outcome.evaluation === "object" ? outcome.evaluation : null
+    }
+  };
+}
+function normalizeTaskRecord(value) {
+  const record = asObject2(value);
+  if (!record)
+    return null;
+  const taskId = asString2(record.task_id);
+  const outcome = asString2(record.outcome);
+  const engine = asString2(record.engine);
+  const startTime = asString2(record.start_time);
+  const endTime = asString2(record.end_time);
+  if (!taskId || !outcome || !engine || !startTime || !endTime) {
+    return null;
+  }
+  return {
+    task_id: taskId,
+    outcome,
+    engine,
+    fallback_taken: asBoolean2(record.fallback_taken),
+    start_time: startTime,
+    end_time: endTime,
+    notes: asStringArray(record.notes),
+    model_id: asNullableString2(record.model_id),
+    cost_tier: asNullableString2(record.cost_tier),
+    spend_units: asNullableNumber2(record.spend_units),
+    cost_guardrail_status: record.cost_guardrail_status === "allow" || record.cost_guardrail_status === "warn" || record.cost_guardrail_status === "block" ? record.cost_guardrail_status : null,
+    cost_guardrail_notes: asStringArray(record.cost_guardrail_notes),
+    routing_evidence: buildRoutingEvidence(record),
+    block_state: normalizeTaskBlockState(record.block_state)
+  };
+}
+function buildRunLedgerSummary(taskQueue, tasksExecuted, spendUnitsConsumed) {
+  const fallbackCount = tasksExecuted.filter((task) => task.routing_evidence.fallback.taken).length;
+  const retryCount = tasksExecuted.reduce(
+    (sum, task) => sum + task.routing_evidence.retries.attempts,
+    0
+  );
+  const providers = new Set(
+    tasksExecuted.map((task) => task.routing_evidence.selection.selected_provider).filter((value) => typeof value === "string" && value !== "")
+  );
+  const models = new Set(
+    tasksExecuted.map((task) => task.routing_evidence.selection.selected_model).filter((value) => typeof value === "string" && value !== "")
+  );
+  const promptTokens = tasksExecuted.reduce((sum, task) => {
+    const value = task.routing_evidence.usage.prompt_tokens;
+    return value === null ? sum : (sum ?? 0) + value;
+  }, null);
+  const completionTokens = tasksExecuted.reduce((sum, task) => {
+    const value = task.routing_evidence.usage.completion_tokens;
+    return value === null ? sum : (sum ?? 0) + value;
+  }, null);
+  const totalTokens = tasksExecuted.reduce((sum, task) => {
+    const value = task.routing_evidence.usage.total_tokens;
+    return value === null ? sum : (sum ?? 0) + value;
+  }, null);
+  return {
+    total_tasks: taskQueue.length,
+    tasks_executed_count: tasksExecuted.length,
+    tasks_remaining_count: Math.max(taskQueue.length - tasksExecuted.length, 0),
+    success_count: tasksExecuted.filter((task) => task.outcome === "success").length,
+    failure_count: tasksExecuted.filter((task) => task.outcome === "failure").length,
+    review_count: tasksExecuted.filter((task) => task.outcome === "skipped_for_review").length,
+    fallback_count: fallbackCount,
+    retry_count: retryCount,
+    engines_used: [...new Set(tasksExecuted.map((task) => task.engine))],
+    providers_used: [...providers],
+    models_used: [...models],
+    spend_units_consumed: spendUnitsConsumed,
+    prompt_tokens: promptTokens,
+    completion_tokens: completionTokens,
+    total_tokens: totalTokens
+  };
+}
+function normalizeRunRecord(value, options = {}) {
+  const record = asObject2(value);
+  if (!record)
+    return null;
+  const runId = asString2(record.run_id);
+  const status = asString2(record.status);
+  const startTime = asString2(record.start_time);
+  if (!runId || !status || !startTime) {
+    return null;
+  }
+  const taskQueue = asStringArray(record.task_queue);
+  const tasksExecuted = Array.isArray(record.tasks_executed) ? record.tasks_executed.map((task) => normalizeTaskRecord(task)).filter((task) => task !== null) : [];
+  const spendUnitsConsumed = asNumber2(record.spend_units_consumed, 0);
+  const existingLedger = asObject2(record.routing_ledger);
+  const existingSummary = asObject2(existingLedger?.run_summary);
+  const compatibilityMode = options.compatibilityMode ?? (asString2(existingLedger?.version) === RUN_LEDGER_VERSION ? "native" : "legacy-normalized");
+  return {
+    run_id: runId,
+    status,
+    task_queue: taskQueue,
+    tasks_executed: tasksExecuted,
+    failure: normalizeFailureRecord(record.failure),
+    spend_units_consumed: spendUnitsConsumed,
+    cost_events: Array.isArray(record.cost_events) ? record.cost_events.map((event) => normalizeCostEventRecord(event)).filter((event) => event !== null) : [],
+    start_time: startTime,
+    end_time: asNullableString2(record.end_time),
+    unattended_execution: normalizeUnattendedExecutionSnapshot(record.unattended_execution),
+    progress_events: Array.isArray(record.progress_events) ? record.progress_events.map((event) => normalizeProgressEventRecord(event)).filter((event) => event !== null) : [],
+    interruption_state: normalizeRunInterruptionState(record.interruption_state),
+    routing_ledger: {
+      version: RUN_LEDGER_VERSION,
+      compatibility_mode: compatibilityMode,
+      run_summary: {
+        ...buildRunLedgerSummary(taskQueue, tasksExecuted, spendUnitsConsumed),
+        total_tasks: asNumber2(existingSummary?.total_tasks, taskQueue.length),
+        tasks_executed_count: asNumber2(existingSummary?.tasks_executed_count, tasksExecuted.length),
+        tasks_remaining_count: asNumber2(
+          existingSummary?.tasks_remaining_count,
+          Math.max(taskQueue.length - tasksExecuted.length, 0)
+        ),
+        success_count: asNumber2(
+          existingSummary?.success_count,
+          tasksExecuted.filter((task) => task.outcome === "success").length
+        ),
+        failure_count: asNumber2(
+          existingSummary?.failure_count,
+          tasksExecuted.filter((task) => task.outcome === "failure").length
+        ),
+        review_count: asNumber2(
+          existingSummary?.review_count,
+          tasksExecuted.filter((task) => task.outcome === "skipped_for_review").length
+        ),
+        fallback_count: asNumber2(
+          existingSummary?.fallback_count,
+          tasksExecuted.filter((task) => task.routing_evidence.fallback.taken).length
+        ),
+        retry_count: asNumber2(
+          existingSummary?.retry_count,
+          tasksExecuted.reduce((sum, task) => sum + task.routing_evidence.retries.attempts, 0)
+        ),
+        engines_used: asStringArray(existingSummary?.engines_used).length > 0 ? asStringArray(existingSummary?.engines_used) : [...new Set(tasksExecuted.map((task) => task.engine))],
+        providers_used: asStringArray(existingSummary?.providers_used),
+        models_used: asStringArray(existingSummary?.models_used),
+        spend_units_consumed: asNullableNumber2(existingSummary?.spend_units_consumed) ?? spendUnitsConsumed,
+        prompt_tokens: asNullableNumber2(existingSummary?.prompt_tokens),
+        completion_tokens: asNullableNumber2(existingSummary?.completion_tokens),
+        total_tokens: asNullableNumber2(existingSummary?.total_tokens)
+      },
+      outcome_placeholders: {
+        requested_by: asNullableString2(asObject2(existingLedger?.outcome_placeholders)?.requested_by),
+        operator_summary: asNullableString2(
+          asObject2(existingLedger?.outcome_placeholders)?.operator_summary
+        ),
+        post_run_review: asNullableString2(
+          asObject2(existingLedger?.outcome_placeholders)?.post_run_review
+        )
+      }
+    }
+  };
+}
+function applyTaskRoutingOutcomeEvaluation(run, taskId, evaluation, outcomePatch = {}) {
+  const targetIndex = [...run.tasks_executed].map((task, index) => ({ task, index })).reverse().find(({ task }) => task.task_id === taskId)?.index;
+  if (targetIndex === void 0) {
+    return run;
+  }
+  const tasksExecuted = run.tasks_executed.map(
+    (task, index) => index !== targetIndex ? task : {
+      ...task,
+      routing_evidence: {
+        ...task.routing_evidence,
+        outcome: {
+          ...task.routing_evidence.outcome,
+          ...outcomePatch,
+          evaluation
+        }
+      }
+    }
+  );
+  return normalizeRunRecord(
+    {
+      ...run,
+      tasks_executed: tasksExecuted
+    },
+    { compatibilityMode: "native" }
+  );
+}
+
+// src/execution-policy.ts
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var import_url2 = require("url");
+var import_meta2 = {};
+var MODULE_DIR2 = typeof __dirname === "string" ? __dirname : path4.dirname((0, import_url2.fileURLToPath)(import_meta2.url));
+var EXECUTION_POLICY_VERSION = "execution-policy-v1";
+var EXECUTION_POLICY_FILENAME = "execution-policy.json";
+var EXECUTION_POLICY_WORKSPACE_PATH = path4.join(
+  "config",
+  EXECUTION_POLICY_FILENAME
+);
+var VALID_POLICY_ESCALATION_BEHAVIORS = [
+  "allow",
+  "require_approval",
+  "halt_and_escalate",
+  "fallback_to_defaults"
+];
+var DEFAULTS_PATH = path4.join(MODULE_DIR2, "defaults", EXECUTION_POLICY_FILENAME);
+var VALID_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function asStringArray2(value) {
+  if (!Array.isArray(value))
+    return void 0;
+  const normalized = value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean);
+  return [...new Set(normalized)];
+}
+function asBoolean3(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function normalizeEscalationBehavior(value) {
+  return typeof value === "string" && VALID_POLICY_ESCALATION_BEHAVIORS.includes(value) ? value : void 0;
+}
+function normalizeAllowedManagers(value) {
+  const values = asStringArray2(value);
+  if (!values)
+    return void 0;
+  const normalized = values.filter(
+    (entry) => VALID_MANAGERS.includes(entry)
+  );
+  return normalized.length > 0 ? normalized : [];
+}
+function normalizeExecutionPolicyOverrides(value) {
+  if (!isRecord(value)) {
+    throw new Error("devory: execution policy config must be a JSON object");
+  }
+  const overrides = {};
+  if (isRecord(value.commands)) {
+    overrides.commands = {};
+    const allow = asStringArray2(value.commands.allow);
+    const requireApproval = asStringArray2(value.commands.require_approval);
+    const forbid = asStringArray2(value.commands.forbid);
+    if (allow)
+      overrides.commands.allow = allow;
+    if (requireApproval)
+      overrides.commands.require_approval = requireApproval;
+    if (forbid)
+      overrides.commands.forbid = forbid;
+  }
+  if (isRecord(value.filesystem)) {
+    overrides.filesystem = {};
+    const writableRoots = asStringArray2(value.filesystem.writable_roots);
+    const readOnlyRoots = asStringArray2(value.filesystem.read_only_roots);
+    const outsideApproval = asBoolean3(
+      value.filesystem.require_approval_outside_writable_roots
+    );
+    if (writableRoots)
+      overrides.filesystem.writable_roots = writableRoots;
+    if (readOnlyRoots)
+      overrides.filesystem.read_only_roots = readOnlyRoots;
+    if (outsideApproval !== void 0) {
+      overrides.filesystem.require_approval_outside_writable_roots = outsideApproval;
+    }
+  }
+  if (isRecord(value.network)) {
+    overrides.network = {};
+    const allow = asBoolean3(value.network.allow);
+    const allowedHosts = asStringArray2(value.network.allowed_hosts);
+    const approvalHosts = asStringArray2(value.network.require_approval_for_hosts);
+    if (allow !== void 0)
+      overrides.network.allow = allow;
+    if (allowedHosts)
+      overrides.network.allowed_hosts = allowedHosts;
+    if (approvalHosts)
+      overrides.network.require_approval_for_hosts = approvalHosts;
+  }
+  if (isRecord(value.package_installs)) {
+    overrides.package_installs = {};
+    const allow = asBoolean3(value.package_installs.allow);
+    const managers = normalizeAllowedManagers(value.package_installs.allowed_managers);
+    const requireApproval = asBoolean3(value.package_installs.require_approval);
+    if (allow !== void 0)
+      overrides.package_installs.allow = allow;
+    if (managers)
+      overrides.package_installs.allowed_managers = managers;
+    if (requireApproval !== void 0) {
+      overrides.package_installs.require_approval = requireApproval;
+    }
+  }
+  if (isRecord(value.test_execution)) {
+    overrides.test_execution = {};
+    const allow = asBoolean3(value.test_execution.allow);
+    const allowedCommands = asStringArray2(value.test_execution.allowed_commands);
+    const approvalCommands = asStringArray2(
+      value.test_execution.require_approval_commands
+    );
+    if (allow !== void 0)
+      overrides.test_execution.allow = allow;
+    if (allowedCommands)
+      overrides.test_execution.allowed_commands = allowedCommands;
+    if (approvalCommands) {
+      overrides.test_execution.require_approval_commands = approvalCommands;
+    }
+  }
+  const approvalRequiredActions = asStringArray2(value.approval_required_actions);
+  if (approvalRequiredActions) {
+    overrides.approval_required_actions = approvalRequiredActions;
+  }
+  const forbiddenActions = asStringArray2(value.forbidden_actions);
+  if (forbiddenActions) {
+    overrides.forbidden_actions = forbiddenActions;
+  }
+  if (isRecord(value.escalation)) {
+    overrides.escalation = {};
+    const unmatched = normalizeEscalationBehavior(value.escalation.unmatched_command);
+    const outOfPolicy = normalizeEscalationBehavior(
+      value.escalation.out_of_policy_action
+    );
+    const invalidPolicy = normalizeEscalationBehavior(value.escalation.invalid_policy);
+    if (unmatched)
+      overrides.escalation.unmatched_command = unmatched;
+    if (outOfPolicy)
+      overrides.escalation.out_of_policy_action = outOfPolicy;
+    if (invalidPolicy)
+      overrides.escalation.invalid_policy = invalidPolicy;
+  }
+  return overrides;
+}
+function applyExecutionPolicyOverrides(base, overrides) {
+  return {
+    ...base,
+    commands: {
+      ...base.commands,
+      ...overrides.commands
+    },
+    filesystem: {
+      ...base.filesystem,
+      ...overrides.filesystem
+    },
+    network: {
+      ...base.network,
+      ...overrides.network
+    },
+    package_installs: {
+      ...base.package_installs,
+      ...overrides.package_installs
+    },
+    test_execution: {
+      ...base.test_execution,
+      ...overrides.test_execution
+    },
+    approval_required_actions: overrides.approval_required_actions ?? base.approval_required_actions,
+    forbidden_actions: overrides.forbidden_actions ?? base.forbidden_actions,
+    escalation: {
+      ...base.escalation,
+      ...overrides.escalation
+    }
+  };
+}
+function loadDefaultExecutionPolicy() {
+  const raw = fs4.readFileSync(DEFAULTS_PATH, "utf-8");
+  const parsed = JSON.parse(raw);
+  const overrides = normalizeExecutionPolicyOverrides(parsed);
+  const base = {
+    version: EXECUTION_POLICY_VERSION,
+    commands: {
+      allow: [],
+      require_approval: [],
+      forbid: []
+    },
+    filesystem: {
+      writable_roots: ["."],
+      read_only_roots: [".git"],
+      require_approval_outside_writable_roots: true
+    },
+    network: {
+      allow: false,
+      allowed_hosts: [],
+      require_approval_for_hosts: ["*"]
+    },
+    package_installs: {
+      allow: false,
+      allowed_managers: [],
+      require_approval: true
+    },
+    test_execution: {
+      allow: true,
+      allowed_commands: [],
+      require_approval_commands: []
+    },
+    approval_required_actions: [
+      "write_outside_workspace",
+      "network_access",
+      "package_install"
+    ],
+    forbidden_actions: ["destructive_delete", "privilege_escalation"],
+    escalation: {
+      unmatched_command: "require_approval",
+      out_of_policy_action: "halt_and_escalate",
+      invalid_policy: "fallback_to_defaults"
+    }
+  };
+  return applyExecutionPolicyOverrides(base, overrides);
+}
+function loadWorkspaceExecutionPolicy(factoryRoot) {
+  const configPath = path4.join(factoryRoot, EXECUTION_POLICY_WORKSPACE_PATH);
+  if (!fs4.existsSync(configPath))
+    return null;
+  const raw = fs4.readFileSync(configPath, "utf-8");
+  return normalizeExecutionPolicyOverrides(JSON.parse(raw));
+}
+function resolveExecutionPolicy(factoryRoot, runOverride) {
+  let policy = loadDefaultExecutionPolicy();
+  const appliedLayers = [
+    "shipped-defaults"
+  ];
+  const workspaceConfigPath = path4.join(factoryRoot, EXECUTION_POLICY_WORKSPACE_PATH);
+  const workspaceOverrides = loadWorkspaceExecutionPolicy(factoryRoot);
+  if (workspaceOverrides) {
+    policy = applyExecutionPolicyOverrides(policy, workspaceOverrides);
+    appliedLayers.push("workspace-config");
+  }
+  if (runOverride !== void 0 && runOverride !== null) {
+    const normalizedOverride = normalizeExecutionPolicyOverrides(runOverride);
+    policy = applyExecutionPolicyOverrides(policy, normalizedOverride);
+    appliedLayers.push("run-override");
+  }
+  return {
+    policy,
+    applied_layers: appliedLayers,
+    workspace_config_path: fs4.existsSync(workspaceConfigPath) ? workspaceConfigPath : null
+  };
+}
+function buildExecutionPolicyInjection(resolution) {
+  return {
+    policy: resolution.policy,
+    injection_source: "agent-context",
+    applied_layers: resolution.applied_layers,
+    workspace_config_path: resolution.workspace_config_path
+  };
+}
+
+// src/task-markdown-renderer.ts
+var TASK_MARKDOWN_RENDERER_VERSION = "task-markdown-renderer-v1";
+var TASK_MARKDOWN_FRONTMATTER_ORDER = [
+  "id",
+  "title",
+  "project",
+  "repo",
+  "branch",
+  "type",
+  "priority",
+  "status",
+  "agent",
+  "lane",
+  "repo_area",
+  "bundle_id",
+  "bundle_title",
+  "bundle_phase",
+  "depends_on",
+  "files_likely_affected",
+  "verification"
+];
+var TASK_MARKDOWN_SECTION_ORDER = [
+  "## Goal",
+  "## Context",
+  "## Acceptance Criteria",
+  "## Expected Artifacts",
+  "## Failure Conditions",
+  "## Reviewer Checklist"
+];
+function slugify(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function buildTaskDraftTargetPath(taskId, title, stage) {
+  return `tasks/${stage}/${taskId}-${slugify(title)}.md`;
+}
+function pushOptionalFrontmatter(lines, key, value) {
+  if (value)
+    lines.push(`${key}: ${value}`);
+}
+function pushArrayField(lines, key, values) {
+  if (values.length === 0) {
+    lines.push(`${key}: []`);
+    return;
+  }
+  lines.push(`${key}:`);
+  for (const value of values)
+    lines.push(`  - ${value}`);
+}
+function pushSection(lines, heading, entries) {
+  lines.push(heading, "");
+  if (entries.length === 0) {
+    lines.push("- (none)");
+  } else {
+    for (const entry of entries)
+      lines.push(`- ${entry}`);
+  }
+  lines.push("");
+}
+function pushReviewerChecklist(lines, entries) {
+  lines.push("## Reviewer Checklist", "");
+  for (const entry of entries)
+    lines.push(`- ${entry}`);
+  lines.push("");
+}
+function renderTaskDraftTarget(draft) {
+  const targetStage = draft.commit.target_stage ?? draft.status;
+  const committedTaskId = draft.commit.committed_task_id ?? draft.draft_id;
+  const targetPath = draft.commit.target_path ?? buildTaskDraftTargetPath(committedTaskId, draft.title, targetStage);
+  const lines = [
+    "---",
+    `id: ${committedTaskId}`,
+    `title: ${draft.title}`,
+    `project: ${draft.project}`,
+    `repo: ${draft.repo}`,
+    `branch: ${draft.branch}`,
+    `type: ${draft.type}`,
+    `priority: ${draft.priority}`,
+    `status: ${targetStage}`,
+    `agent: ${draft.agent}`
+  ];
+  pushOptionalFrontmatter(lines, "lane", draft.lane);
+  pushOptionalFrontmatter(lines, "repo_area", draft.repo_area);
+  pushOptionalFrontmatter(lines, "bundle_id", draft.bundle_id);
+  pushOptionalFrontmatter(lines, "bundle_title", draft.bundle_title);
+  pushOptionalFrontmatter(lines, "bundle_phase", draft.bundle_phase);
+  pushArrayField(lines, "depends_on", draft.depends_on);
+  pushArrayField(lines, "files_likely_affected", draft.files_likely_affected);
+  pushArrayField(lines, "verification", draft.verification);
+  lines.push("---", "", "## Goal", "", draft.goal, "");
+  pushSection(lines, "## Context", draft.context);
+  pushSection(lines, "## Acceptance Criteria", draft.acceptance_criteria);
+  pushSection(lines, "## Expected Artifacts", draft.expected_artifacts);
+  pushSection(lines, "## Failure Conditions", draft.failure_conditions);
+  pushReviewerChecklist(lines, draft.reviewer_checklist);
+  return {
+    target_stage: targetStage,
+    target_path: targetPath,
+    markdown: lines.join("\n").trimEnd() + "\n"
+  };
+}
+function renderTaskDraftMarkdown(draft) {
+  return renderTaskDraftTarget(draft).markdown;
+}
+
+// src/planning-draft.ts
+var PLANNING_DRAFT_CONTRACT_VERSION = "planning-draft-v1";
+var PLANNING_DRAFT_KINDS = ["epic", "task"];
+var PLANNING_DRAFT_PERSISTENCE_MODES = [
+  "ephemeral",
+  "artifact"
+];
+var PLANNING_DRAFT_COMMIT_STATES = [
+  "draft",
+  "ready_to_commit",
+  "committed"
+];
+var PLANNING_DRAFT_VALIDATION_STATUSES = [
+  "unchecked",
+  "valid",
+  "invalid"
+];
+var TASK_DRAFT_COMMIT_STAGES = [
+  "backlog",
+  "ready",
+  "doing",
+  "review",
+  "blocked",
+  "done"
+];
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function asString3(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : null;
+}
+function asOptionalString(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+function asStringArray3(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim() !== "") : [];
+}
+function normalizePersistenceMode(value) {
+  return value === "ephemeral" ? "ephemeral" : "artifact";
+}
+function normalizeCommitState(value) {
+  return value === "ready_to_commit" || value === "committed" ? value : "draft";
+}
+function normalizeCommitStage(value) {
+  return typeof value === "string" && TASK_DRAFT_COMMIT_STAGES.includes(value) ? value : null;
+}
+function normalizeValidationStatus(value) {
+  return value === "valid" || value === "invalid" ? value : "unchecked";
+}
+function normalizeStorage(value) {
+  const record = isRecord2(value) ? value : {};
+  return {
+    authority: "planning-draft",
+    persistence_mode: normalizePersistenceMode(record.persistence_mode),
+    artifact_path: asString3(record.artifact_path)
+  };
+}
+function normalizeCommit(value) {
+  const record = isRecord2(value) ? value : {};
+  return {
+    state: normalizeCommitState(record.state),
+    target_stage: normalizeCommitStage(record.target_stage),
+    target_path: asString3(record.target_path),
+    committed_task_id: asString3(record.committed_task_id)
+  };
+}
+function normalizeValidation(value) {
+  const record = isRecord2(value) ? value : {};
+  return {
+    status: normalizeValidationStatus(record.status),
+    errors: asStringArray3(record.errors),
+    warnings: asStringArray3(record.warnings)
+  };
+}
+function normalizeBase(value) {
+  const record = isRecord2(value) ? value : null;
+  if (!record)
+    return null;
+  const draftId = asString3(record.draft_id);
+  const createdAt = asString3(record.created_at);
+  const updatedAt = asString3(record.updated_at);
+  const title = asString3(record.title);
+  const kind = record.kind === "epic" || record.kind === "task" ? record.kind : null;
+  if (!draftId || !createdAt || !updatedAt || !title || !kind)
+    return null;
+  return {
+    version: PLANNING_DRAFT_CONTRACT_VERSION,
+    draft_id: draftId,
+    kind,
+    created_at: createdAt,
+    updated_at: updatedAt,
+    title,
+    notes: asStringArray3(record.notes),
+    storage: normalizeStorage(record.storage),
+    commit: normalizeCommit(record.commit),
+    validation: normalizeValidation(record.validation)
+  };
+}
+function buildPlanningDraftStorageRelativePath(kind, draftId) {
+  return `planning-drafts/${kind}/${draftId}.json`;
+}
+function buildPlanningDraftArtifactPath(kind, draftId) {
+  return `artifacts/${buildPlanningDraftStorageRelativePath(kind, draftId)}`;
+}
+function buildEpicPlanningDraftFixture(overrides = {}) {
+  const draftId = overrides.draft_id ?? "epic-draft-auth-reliability";
+  const artifactPath = overrides.storage?.artifact_path ?? buildPlanningDraftArtifactPath("epic", draftId);
+  return {
+    version: PLANNING_DRAFT_CONTRACT_VERSION,
+    draft_id: draftId,
+    kind: "epic",
+    created_at: overrides.created_at ?? "2026-03-29T00:00:00.000Z",
+    updated_at: overrides.updated_at ?? "2026-03-29T00:00:00.000Z",
+    title: overrides.title ?? "Improve auth and review workflow reliability",
+    objective: overrides.objective ?? "Reduce operator friction by making planning, review, and recovery flows more predictable.",
+    scope: overrides.scope ?? [
+      "Define the planning draft contract",
+      "Persist epic intent before task generation"
+    ],
+    out_of_scope: overrides.out_of_scope ?? [
+      "Replacing the existing markdown task storage contract"
+    ],
+    constraints: overrides.constraints ?? [
+      "Committed tasks must remain valid against the current validator",
+      "Draft records must remain separate from lifecycle folders"
+    ],
+    risks: overrides.risks ?? [
+      "UI and generator layers could drift without one shared schema"
+    ],
+    success_criteria: overrides.success_criteria ?? [
+      "Epic intent can be saved and reopened without markdown editing",
+      "Generated task drafts can map back to the current markdown protocol"
+    ],
+    notes: overrides.notes ?? ["Used as a stable contract fixture for planning flows."],
+    storage: overrides.storage ?? {
+      authority: "planning-draft",
+      persistence_mode: "artifact",
+      artifact_path: artifactPath
+    },
+    commit: overrides.commit ?? {
+      state: "draft",
+      target_stage: null,
+      target_path: null,
+      committed_task_id: null
+    },
+    validation: overrides.validation ?? {
+      status: "unchecked",
+      errors: [],
+      warnings: []
+    }
+  };
+}
+function buildEpicPlanningDraft(input) {
+  const createdAt = input.created_at ?? (/* @__PURE__ */ new Date()).toISOString();
+  const updatedAt = input.updated_at ?? createdAt;
+  const artifactPath = input.artifact_path === null ? null : input.artifact_path ?? buildPlanningDraftArtifactPath("epic", input.draft_id);
+  return {
+    version: PLANNING_DRAFT_CONTRACT_VERSION,
+    draft_id: input.draft_id,
+    kind: "epic",
+    created_at: createdAt,
+    updated_at: updatedAt,
+    title: input.title.trim(),
+    objective: input.objective.trim(),
+    scope: input.scope ?? [],
+    out_of_scope: input.out_of_scope ?? [],
+    constraints: input.constraints ?? [],
+    risks: input.risks ?? [],
+    success_criteria: input.success_criteria ?? [],
+    notes: input.notes ?? [],
+    storage: {
+      authority: "planning-draft",
+      persistence_mode: input.persistence_mode ?? "artifact",
+      artifact_path: artifactPath
+    },
+    commit: {
+      state: "draft",
+      target_stage: null,
+      target_path: null,
+      committed_task_id: null
+    },
+    validation: {
+      status: "unchecked",
+      errors: [],
+      warnings: []
+    }
+  };
+}
+function buildTaskPlanningDraftFixture(overrides = {}) {
+  const taskId = overrides.commit?.committed_task_id ?? overrides.draft_id ?? "factory-181";
+  const title = overrides.title ?? "Define the structured planning draft model for epics and tasks";
+  const status = overrides.status ?? "backlog";
+  const externalSource = overrides.external_source;
+  const externalKey = overrides.external_key;
+  const externalUrl = overrides.external_url;
+  const artifactPath = overrides.storage?.artifact_path ?? buildPlanningDraftArtifactPath("task", taskId);
+  const targetPath = overrides.commit?.target_path ?? buildTaskDraftTargetPath(taskId, title, status);
+  return {
+    version: PLANNING_DRAFT_CONTRACT_VERSION,
+    draft_id: overrides.draft_id ?? taskId,
+    kind: "task",
+    created_at: overrides.created_at ?? "2026-03-29T00:00:00.000Z",
+    updated_at: overrides.updated_at ?? "2026-03-29T00:00:00.000Z",
+    title,
+    project: overrides.project ?? "ai-dev-factory",
+    repo: overrides.repo ?? ".",
+    branch: overrides.branch ?? `task/${taskId}-planning-draft-contract`,
+    type: overrides.type ?? "feature",
+    priority: overrides.priority ?? "high",
+    status,
+    agent: overrides.agent ?? "backend-builder",
+    ...externalSource ? { external_source: externalSource } : {},
+    ...externalKey ? { external_key: externalKey } : {},
+    ...externalUrl ? { external_url: externalUrl } : {},
+    depends_on: overrides.depends_on ?? [],
+    files_likely_affected: overrides.files_likely_affected ?? [
+      "docs/adr/",
+      "packages/core/src/"
+    ],
+    verification: overrides.verification ?? [
+      "npm run validate:task -- tasks/backlog/factory-181.md",
+      "npm run test"
+    ],
+    lane: overrides.lane,
+    repo_area: overrides.repo_area,
+    bundle_id: overrides.bundle_id,
+    bundle_title: overrides.bundle_title,
+    bundle_phase: overrides.bundle_phase,
+    goal: overrides.goal ?? "Define a shared draft contract for epic and task authoring before markdown commit time.",
+    context: overrides.context ?? [
+      "Markdown task storage already exists and remains authoritative after commit.",
+      "Planning flows need a durable structure above raw markdown."
+    ],
+    acceptance_criteria: overrides.acceptance_criteria ?? [
+      "A shared planning draft contract exists for epics and tasks.",
+      "Task drafts render to markdown compatible with the current validator."
+    ],
+    expected_artifacts: overrides.expected_artifacts ?? [
+      "Planning draft ADR",
+      "Shared planning draft types",
+      "Planning draft contract tests"
+    ],
+    failure_conditions: overrides.failure_conditions ?? [
+      "Draft storage semantics are left ambiguous",
+      "Rendered task markdown diverges from the current protocol"
+    ],
+    reviewer_checklist: overrides.reviewer_checklist ?? [
+      "[ ] Contract covers epic and task drafts",
+      "[ ] Draft storage remains distinct from lifecycle folders",
+      "[ ] Rendered task target stays validator-compatible"
+    ],
+    notes: overrides.notes ?? ["Canonical fixture for planning draft tests."],
+    storage: overrides.storage ?? {
+      authority: "planning-draft",
+      persistence_mode: "artifact",
+      artifact_path: artifactPath
+    },
+    commit: overrides.commit ?? {
+      state: "ready_to_commit",
+      target_stage: status,
+      target_path: targetPath,
+      committed_task_id: taskId
+    },
+    validation: overrides.validation ?? {
+      status: "valid",
+      errors: [],
+      warnings: []
+    }
+  };
+}
+function updateEpicPlanningDraft(draft, patch) {
+  return {
+    ...draft,
+    title: patch.title?.trim() || draft.title,
+    objective: patch.objective?.trim() || draft.objective,
+    scope: patch.scope ?? draft.scope,
+    out_of_scope: patch.out_of_scope ?? draft.out_of_scope,
+    constraints: patch.constraints ?? draft.constraints,
+    risks: patch.risks ?? draft.risks,
+    success_criteria: patch.success_criteria ?? draft.success_criteria,
+    notes: patch.notes ?? draft.notes,
+    updated_at: patch.updated_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+    validation: patch.validation ? {
+      status: patch.validation.status ?? draft.validation.status,
+      errors: patch.validation.errors ?? draft.validation.errors,
+      warnings: patch.validation.warnings ?? draft.validation.warnings
+    } : draft.validation
+  };
+}
+function normalizePlanningDraft(value) {
+  const base = normalizeBase(value);
+  const record = isRecord2(value) ? value : null;
+  if (!base || !record)
+    return null;
+  if (base.kind === "epic") {
+    const objective = asString3(record.objective);
+    if (!objective)
+      return null;
+    return {
+      ...base,
+      kind: "epic",
+      objective,
+      scope: asStringArray3(record.scope),
+      out_of_scope: asStringArray3(record.out_of_scope),
+      constraints: asStringArray3(record.constraints),
+      risks: asStringArray3(record.risks),
+      success_criteria: asStringArray3(record.success_criteria)
+    };
+  }
+  const project = asString3(record.project);
+  const repo = asString3(record.repo);
+  const branch = asString3(record.branch);
+  const type2 = asString3(record.type);
+  const priority = asString3(record.priority);
+  const agent = asString3(record.agent);
+  const goal = asString3(record.goal);
+  if (!project || !repo || !branch || !type2 || !priority || !agent || !goal) {
+    return null;
+  }
+  const externalSource = record.external_source === "github-issue" || record.external_source === "jira" ? record.external_source : void 0;
+  const externalKey = asOptionalString(record.external_key);
+  const externalUrl = asOptionalString(record.external_url);
+  return {
+    ...base,
+    kind: "task",
+    project,
+    repo,
+    branch,
+    type: type2,
+    priority,
+    status: normalizeCommitStage(record.status) ?? "backlog",
+    agent,
+    ...externalSource ? { external_source: externalSource } : {},
+    ...externalKey ? { external_key: externalKey } : {},
+    ...externalUrl ? { external_url: externalUrl } : {},
+    depends_on: asStringArray3(record.depends_on),
+    files_likely_affected: asStringArray3(record.files_likely_affected),
+    verification: asStringArray3(record.verification),
+    lane: asOptionalString(record.lane),
+    repo_area: asOptionalString(record.repo_area),
+    bundle_id: asOptionalString(record.bundle_id),
+    bundle_title: asOptionalString(record.bundle_title),
+    bundle_phase: asOptionalString(record.bundle_phase),
+    goal,
+    context: asStringArray3(record.context),
+    acceptance_criteria: asStringArray3(record.acceptance_criteria),
+    expected_artifacts: asStringArray3(record.expected_artifacts),
+    failure_conditions: asStringArray3(record.failure_conditions),
+    reviewer_checklist: asStringArray3(record.reviewer_checklist)
+  };
+}
+function renderTaskPlanningDraftTarget(draft) {
+  return renderTaskDraftTarget(draft);
+}
+function serializePlanningDraft(draft) {
+  const normalized = normalizePlanningDraft(draft);
+  if (!normalized) {
+    throw new Error(`Cannot serialize invalid planning draft: ${draft.draft_id}`);
+  }
+  return JSON.stringify(normalized, null, 2) + "\n";
+}
+
+// src/task-draft.ts
+var TASK_DRAFT_RENDER_CONTRACT_VERSION = "task-draft-render-v1";
+var TASK_DRAFT_REQUIRED_FRONTMATTER_FIELDS = [
+  "id",
+  "title",
+  "project",
+  "repo",
+  "branch",
+  "type",
+  "priority",
+  "status",
+  "agent"
+];
+var TASK_DRAFT_OPTIONAL_FRONTMATTER_FIELDS = [
+  "lane",
+  "repo_area",
+  "bundle_id",
+  "bundle_title",
+  "bundle_phase",
+  "depends_on",
+  "files_likely_affected",
+  "verification"
+];
+var TASK_DRAFT_BODY_SECTION_ORDER = [
+  "## Goal",
+  "## Context",
+  "## Acceptance Criteria",
+  "## Expected Artifacts",
+  "## Failure Conditions",
+  "## Reviewer Checklist"
+];
+function normalizeTaskDraft(value) {
+  const draft = normalizePlanningDraft(value);
+  return draft?.kind === "task" ? draft : null;
+}
+function buildMinimalTaskDraftFixture(overrides = {}) {
+  return buildTaskPlanningDraftFixture({
+    draft_id: overrides.draft_id ?? "factory-184-minimal",
+    title: overrides.title ?? "Define minimal task draft contract",
+    project: overrides.project ?? "ai-dev-factory",
+    repo: overrides.repo ?? ".",
+    branch: overrides.branch ?? "task/factory-184-minimal-task-draft-contract",
+    type: overrides.type ?? "feature",
+    priority: overrides.priority ?? "high",
+    status: overrides.status ?? "backlog",
+    agent: overrides.agent ?? "backend-builder",
+    external_source: overrides.external_source,
+    external_key: overrides.external_key,
+    external_url: overrides.external_url,
+    goal: overrides.goal ?? "Define the minimum structured task draft that renders to valid Devory markdown.",
+    context: overrides.context ?? [
+      "The render contract must remain compatible with the current validators."
+    ],
+    acceptance_criteria: overrides.acceptance_criteria ?? [
+      "A minimal task draft renders to valid markdown."
+    ],
+    expected_artifacts: overrides.expected_artifacts ?? [
+      "Shared task draft contract"
+    ],
+    failure_conditions: overrides.failure_conditions ?? [
+      "Rendered markdown omits required sections"
+    ],
+    reviewer_checklist: overrides.reviewer_checklist ?? [
+      "[ ] Minimal draft is validator-compatible"
+    ],
+    depends_on: overrides.depends_on ?? [],
+    files_likely_affected: overrides.files_likely_affected ?? [],
+    verification: overrides.verification ?? ["npm run test"],
+    lane: overrides.lane,
+    repo_area: overrides.repo_area,
+    bundle_id: overrides.bundle_id,
+    bundle_title: overrides.bundle_title,
+    bundle_phase: overrides.bundle_phase
+  });
+}
+function buildRichTaskDraftFixture(overrides = {}) {
+  return buildTaskPlanningDraftFixture({
+    draft_id: overrides.draft_id ?? "factory-184-rich",
+    title: overrides.title ?? "Define rich task draft contract with optional metadata",
+    project: overrides.project ?? "ai-dev-factory",
+    repo: overrides.repo ?? ".",
+    branch: overrides.branch ?? "task/factory-184-rich-task-draft-contract",
+    type: overrides.type ?? "feature",
+    priority: overrides.priority ?? "high",
+    status: overrides.status ?? "backlog",
+    agent: overrides.agent ?? "backend-builder",
+    external_source: overrides.external_source,
+    external_key: overrides.external_key,
+    external_url: overrides.external_url,
+    lane: overrides.lane ?? "planning",
+    repo_area: overrides.repo_area ?? "authoring",
+    bundle_id: overrides.bundle_id ?? "epic-planning-authoring",
+    bundle_title: overrides.bundle_title ?? "Planning & Task Authoring",
+    bundle_phase: overrides.bundle_phase ?? "contract",
+    depends_on: overrides.depends_on ?? ["factory-181"],
+    files_likely_affected: overrides.files_likely_affected ?? [
+      "packages/core/src/",
+      "templates/"
+    ],
+    verification: overrides.verification ?? [
+      "npm run validate:task -- tasks/backlog/factory-184.md",
+      "npm run test"
+    ],
+    goal: overrides.goal ?? "Define the rich structured task draft contract including optional metadata and render ordering.",
+    context: overrides.context ?? [
+      "Task drafts must support workflow metadata such as dependencies and bundle linkage.",
+      "Rendered markdown must remain compatible with existing readers and validators."
+    ],
+    acceptance_criteria: overrides.acceptance_criteria ?? [
+      "Optional metadata renders deterministically.",
+      "Required sections preserve the existing heading order."
+    ],
+    expected_artifacts: overrides.expected_artifacts ?? [
+      "Task draft contract module",
+      "Task render contract fixture",
+      "Task draft tests"
+    ],
+    failure_conditions: overrides.failure_conditions ?? [
+      "Optional metadata ordering drifts across renderers",
+      "Rendered markdown breaks current task readers"
+    ],
+    reviewer_checklist: overrides.reviewer_checklist ?? [
+      "[ ] Rich draft covers optional metadata",
+      "[ ] Markdown ordering is explicit and deterministic"
+    ]
+  });
+}
+function renderTaskDraftMarkdown2(draft) {
+  return renderTaskDraftMarkdown(draft);
+}
+function renderTaskDraftTarget2(draft) {
+  return renderTaskDraftTarget(draft);
+}
+function buildTaskDraftRenderFixture(input = {}) {
+  const draft = input.richness === "rich" ? buildRichTaskDraftFixture(input.draft) : buildMinimalTaskDraftFixture(input.draft);
+  return renderTaskDraftTarget2({
+    ...draft,
+    status: input.target_stage ?? draft.status,
+    commit: {
+      ...draft.commit,
+      target_stage: input.target_stage ?? draft.commit.target_stage ?? draft.status
+    }
+  });
+}
+
+// src/task-validation.ts
+var REQUIRED_FIELDS = [
+  "id",
+  "title",
+  "project",
+  "status",
+  "agent"
+];
+function validateTaskCapabilityMetadata(meta) {
+  const errors = [];
+  if (meta.required_tier !== void 0 && typeof meta.required_tier === "string" && meta.required_tier.trim() === "") {
+    errors.push('Task capability metadata "required_tier" cannot be empty');
+  }
+  if (!Array.isArray(meta.required_features)) {
+    return errors;
+  }
+  for (const [index, feature] of meta.required_features.entries()) {
+    if (typeof feature !== "string" || feature.trim() === "") {
+      errors.push(
+        `Task capability metadata "required_features" entry ${index + 1} must be a non-empty string`
+      );
+    }
+  }
+  return errors;
+}
+function validateTask(meta, expectedStatus) {
+  const errors = [];
+  for (const field of REQUIRED_FIELDS) {
+    const value = meta[field];
+    if (value === void 0 || value === null || String(value).trim() === "") {
+      errors.push(`Missing required field: "${field}"`);
+    }
+  }
+  if (meta.status && meta.status !== expectedStatus) {
+    errors.push(`Expected status "${expectedStatus}", got "${meta.status}"`);
+  }
+  errors.push(...validateTaskCapabilityMetadata(meta));
+  return { valid: errors.length === 0, errors, warnings: [] };
+}
+var REQUIRED_BODY_SECTIONS = [
+  "## Goal",
+  "## Context",
+  "## Acceptance Criteria",
+  "## Expected Artifacts",
+  "## Failure Conditions"
+];
+function extractSectionContent(body, heading) {
+  const lines = body.split("\n");
+  const start = lines.findIndex((line) => line.trim() === heading);
+  if (start === -1)
+    return [];
+  const content = [];
+  for (let i = start + 1; i < lines.length; i += 1) {
+    const line = lines[i] ?? "";
+    if (line.startsWith("## ") || line.startsWith("# "))
+      break;
+    if (line.trim())
+      content.push(line.trim());
+  }
+  return content;
+}
+function validateTaskBody(body) {
+  const errors = [];
+  const warnings = [];
+  for (const section of REQUIRED_BODY_SECTIONS) {
+    if (!body.includes(section)) {
+      errors.push(`Missing required section: "${section}"`);
+    }
+  }
+  const criteriaContent = extractSectionContent(body, "## Acceptance Criteria");
+  const criteriaItems = criteriaContent.filter((line) => line.startsWith("- "));
+  if (criteriaItems.length === 0 && body.includes("## Acceptance Criteria")) {
+    errors.push(`"## Acceptance Criteria" has no items \u2014 add at least one "- " line`);
+  }
+  if (!body.includes("## Reviewer Checklist")) {
+    warnings.push(`"## Reviewer Checklist" section is missing \u2014 consider adding one`);
+  } else {
+    const checklistContent = extractSectionContent(body, "## Reviewer Checklist");
+    const checklistItems = checklistContent.filter((line) => line.startsWith("- "));
+    if (checklistItems.length === 0) {
+      warnings.push(`"## Reviewer Checklist" has no items`);
+    }
+  }
+  return { errors, warnings };
+}
+function validateTaskMarkdown(markdown, expectedStatus) {
+  const { meta, body } = parseFrontmatter(markdown);
+  const statusToCheck = expectedStatus ?? meta.status ?? "";
+  const frontmatterResult = validateTask(meta, statusToCheck);
+  const bodyResult = validateTaskBody(body);
+  const errors = [...frontmatterResult.errors, ...bodyResult.errors];
+  const warnings = [...frontmatterResult.warnings, ...bodyResult.warnings];
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function validateTaskDraft(draft, expectedStatus) {
+  const rendered = renderTaskDraftTarget(draft);
+  const targetStage = expectedStatus ?? rendered.target_stage;
+  const validation = validateTaskMarkdown(rendered.markdown, targetStage);
+  return {
+    ...validation,
+    draft_id: draft.draft_id,
+    target_stage: targetStage,
+    target_path: rendered.target_path
+  };
+}
+function toPlanningDraftValidationRecord(result) {
+  return {
+    status: result.errors.length === 0 ? "valid" : "invalid",
+    errors: [...result.errors],
+    warnings: [...result.warnings]
+  };
+}
+function applyTaskDraftValidation(draft, expectedStatus) {
+  const result = validateTaskDraft(draft, expectedStatus);
+  return {
+    ...draft,
+    validation: toPlanningDraftValidationRecord(result)
+  };
+}
+
+// src/unattended-checkpoint.ts
+var UNATTENDED_CHECKPOINT_VERSION = "unattended-checkpoint-v1";
+var UNATTENDED_CHECKPOINT_TRIGGERS = [
+  "recovery_sensitive_transition",
+  "significant_progress",
+  "retry_boundary",
+  "compaction_boundary"
+];
+function isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function asString4(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : null;
+}
+function asNumber3(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asStringArray4(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim() !== "") : [];
+}
+function normalizeTrigger(value) {
+  return typeof value === "string" && UNATTENDED_CHECKPOINT_TRIGGERS.includes(value) ? value : "significant_progress";
+}
+function normalizePolicySnapshot(value) {
+  const record = isRecord3(value) ? value : {};
+  return {
+    policy: isRecord3(record.policy) ? record.policy : null,
+    injection_source: record.injection_source === "agent-context" ? "agent-context" : "checkpoint-writer",
+    applied_layers: asStringArray4(record.applied_layers),
+    workspace_config_path: asString4(record.workspace_config_path)
+  };
+}
+function normalizeArtifactReferences(value) {
+  const record = isRecord3(value) ? value : {};
+  return {
+    heartbeat_snapshot: asString4(record.heartbeat_snapshot),
+    task_snapshot: asString4(record.task_snapshot),
+    execution_plan: asString4(record.execution_plan),
+    staging_manifest: asString4(record.staging_manifest),
+    agent_context: asString4(record.agent_context),
+    routing_manifest: asString4(record.routing_manifest),
+    execution_result: asString4(record.execution_result),
+    retry_context: asString4(record.retry_context),
+    review_package: asString4(record.review_package),
+    changed_files: asString4(record.changed_files)
+  };
+}
+function normalizeUnattendedCheckpointArtifact(value) {
+  const record = isRecord3(value) ? value : null;
+  if (!record)
+    return null;
+  const checkpointId = asString4(record.checkpoint_id);
+  const runId = asString4(record.run_id);
+  const createdAt = asString4(record.created_at);
+  const currentPhase = asString4(record.current_phase);
+  if (!checkpointId || !runId || !createdAt || !currentPhase)
+    return null;
+  return {
+    version: UNATTENDED_CHECKPOINT_VERSION,
+    checkpoint_id: checkpointId,
+    run_id: runId,
+    task_id: asString4(record.task_id),
+    created_at: createdAt,
+    trigger: normalizeTrigger(record.trigger),
+    current_phase: currentPhase,
+    current_adapter: asString4(record.current_adapter),
+    current_attempt: asNumber3(record.current_attempt),
+    recent_progress_summary: asString4(record.recent_progress_summary),
+    pending_actions: asStringArray4(record.pending_actions),
+    policy_snapshot: normalizePolicySnapshot(record.policy_snapshot),
+    artifact_references: normalizeArtifactReferences(record.artifact_references)
+  };
+}
+
+// src/review-control.ts
+var REVIEW_CONTROL_CONTRACT_VERSION = "review-control-surface-v1";
+var TASK_REVIEW_ACTIONS = ["approve", "send-back", "block"];
+var REVIEW_CONTROL_ACTIONS = [
+  ...TASK_REVIEW_ACTIONS,
+  "resume-run"
+];
+var REVIEW_QUEUE_ITEM_KINDS = [
+  "task-review",
+  "run-attention",
+  "task-triage"
+];
+var REVIEW_QUEUE_TASK_STAGES = ["review"];
+var REVIEW_QUEUE_TRIAGE_STAGES = ["blocked"];
+var REVIEW_QUEUE_RUN_STATUSES = RESUMABLE_RUN_STATUSES;
+var TASK_REVIEW_ACTION_STAGE_MAP = {
+  approve: "done",
+  "send-back": "doing",
+  block: "blocked"
+};
+var REVIEW_CONTROL_MECHANISMS = {
+  approve: {
+    action: "approve",
+    supported_item_kinds: ["task-review"],
+    workflow_mechanism: "task-review-action",
+    api_route: "/api/task/review-action",
+    cli_equivalent: "devory task move <task> --to done",
+    resulting_state: "task stage review -> done",
+    audit_artifacts: ["artifacts/runs/*-review.md", "runs/<run-id>.json"]
+  },
+  "send-back": {
+    action: "send-back",
+    supported_item_kinds: ["task-review"],
+    workflow_mechanism: "task-review-action",
+    api_route: "/api/task/review-action",
+    cli_equivalent: "devory task move <task> --to doing",
+    resulting_state: "task stage review -> doing",
+    audit_artifacts: ["artifacts/runs/*-review.md", "runs/<run-id>.json"]
+  },
+  block: {
+    action: "block",
+    supported_item_kinds: ["task-review"],
+    workflow_mechanism: "task-review-action",
+    api_route: "/api/task/review-action",
+    cli_equivalent: "devory task move <task> --to blocked",
+    resulting_state: "task stage review -> blocked",
+    audit_artifacts: ["artifacts/runs/*-review.md", "runs/<run-id>.json"]
+  },
+  "resume-run": {
+    action: "resume-run",
+    supported_item_kinds: ["run-attention"],
+    workflow_mechanism: "run-resume",
+    api_route: "/api/run/resume",
+    cli_equivalent: "devory run --resume <run-id>",
+    resulting_state: "run status failed|paused_for_review -> running",
+    audit_artifacts: [
+      "runs/<run-id>.json",
+      "artifacts/execution/<task>/checkpoints/*.json",
+      "artifacts/runs/*-resume.md when mediated by a human question"
+    ]
+  }
+};
+var REVIEW_SUPPORTED_ACTIONS_BY_KIND = {
+  "task-review": TASK_REVIEW_ACTIONS,
+  "run-attention": ["resume-run"],
+  "task-triage": []
+};
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asString5(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : null;
+}
+function asActionList(value) {
+  return Array.isArray(value) ? value.filter(
+    (entry) => typeof entry === "string" && REVIEW_CONTROL_ACTIONS.includes(entry)
+  ) : [];
+}
+function normalizeTaskSource(value, expectedStage) {
+  const record = asRecord(value);
+  if (!record)
+    return null;
+  if (record.authority !== "tasks-folder")
+    return null;
+  if (record.stage !== expectedStage)
+    return null;
+  return { authority: "tasks-folder", stage: expectedStage };
+}
+function normalizeRunSource(value) {
+  const record = asRecord(value);
+  if (!record)
+    return null;
+  if (record.authority !== "run-ledger")
+    return null;
+  if (typeof record.status !== "string" || !REVIEW_QUEUE_RUN_STATUSES.includes(record.status)) {
+    return null;
+  }
+  return {
+    authority: "run-ledger",
+    status: record.status
+  };
+}
+function getSupportedReviewActions(kind) {
+  return REVIEW_SUPPORTED_ACTIONS_BY_KIND[kind];
+}
+function buildTaskReviewQueueItem(input) {
+  return {
+    version: REVIEW_CONTROL_CONTRACT_VERSION,
+    item_id: `task-review:${input.task_id}`,
+    kind: "task-review",
+    title: input.title,
+    summary: input.summary,
+    task_id: input.task_id,
+    run_id: input.run_id ?? null,
+    attention_state: "review",
+    supported_actions: TASK_REVIEW_ACTIONS,
+    source: {
+      authority: "tasks-folder",
+      stage: "review"
+    }
+  };
+}
+function buildRunAttentionQueueItem(input) {
+  return {
+    version: REVIEW_CONTROL_CONTRACT_VERSION,
+    item_id: `run-attention:${input.run_id}`,
+    kind: "run-attention",
+    title: input.title,
+    summary: input.summary,
+    task_id: input.task_id ?? null,
+    run_id: input.run_id,
+    attention_state: input.status,
+    supported_actions: ["resume-run"],
+    source: {
+      authority: "run-ledger",
+      status: input.status
+    }
+  };
+}
+function buildTaskTriageQueueItem(input) {
+  return {
+    version: REVIEW_CONTROL_CONTRACT_VERSION,
+    item_id: `task-triage:${input.task_id}`,
+    kind: "task-triage",
+    title: input.title,
+    summary: input.summary,
+    task_id: input.task_id,
+    run_id: input.run_id ?? null,
+    attention_state: "blocked",
+    supported_actions: [],
+    source: {
+      authority: "tasks-folder",
+      stage: "blocked"
+    }
+  };
+}
+function normalizeReviewQueueItem(value) {
+  const record = asRecord(value);
+  if (!record)
+    return null;
+  const itemId = asString5(record.item_id);
+  const kind = asString5(record.kind);
+  const title = asString5(record.title);
+  const summary = asString5(record.summary);
+  const attentionState = asString5(record.attention_state);
+  if (!itemId || !kind || !title || !summary || !attentionState) {
+    return null;
+  }
+  if (kind === "task-review") {
+    const taskId = asString5(record.task_id);
+    const source = normalizeTaskSource(record.source, "review");
+    const supportedActions = asActionList(record.supported_actions);
+    if (!taskId || attentionState !== "review" || !source || supportedActions.length !== TASK_REVIEW_ACTIONS.length) {
+      return null;
+    }
+    return {
+      version: REVIEW_CONTROL_CONTRACT_VERSION,
+      item_id: itemId,
+      kind,
+      title,
+      summary,
+      task_id: taskId,
+      run_id: asString5(record.run_id),
+      attention_state: "review",
+      supported_actions: TASK_REVIEW_ACTIONS,
+      source
+    };
+  }
+  if (kind === "run-attention") {
+    const runId = asString5(record.run_id);
+    const source = normalizeRunSource(record.source);
+    const supportedActions = asActionList(record.supported_actions);
+    if (!runId || !source || attentionState !== source.status || supportedActions.length !== 1 || supportedActions[0] !== "resume-run") {
+      return null;
+    }
+    return {
+      version: REVIEW_CONTROL_CONTRACT_VERSION,
+      item_id: itemId,
+      kind,
+      title,
+      summary,
+      task_id: asString5(record.task_id),
+      run_id: runId,
+      attention_state: source.status,
+      supported_actions: ["resume-run"],
+      source
+    };
+  }
+  if (kind === "task-triage") {
+    const taskId = asString5(record.task_id);
+    const source = normalizeTaskSource(record.source, "blocked");
+    const supportedActions = asActionList(record.supported_actions);
+    if (!taskId || attentionState !== "blocked" || !source || supportedActions.length !== 0) {
+      return null;
+    }
+    return {
+      version: REVIEW_CONTROL_CONTRACT_VERSION,
+      item_id: itemId,
+      kind,
+      title,
+      summary,
+      task_id: taskId,
+      run_id: asString5(record.run_id),
+      attention_state: "blocked",
+      supported_actions: [],
+      source
+    };
+  }
+  return null;
+}
+
+// src/unattended-stall-policy.ts
+var fs5 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var import_url3 = require("url");
+var import_meta3 = {};
+var MODULE_DIR3 = typeof __dirname === "string" ? __dirname : path5.dirname((0, import_url3.fileURLToPath)(import_meta3.url));
+var UNATTENDED_STALL_POLICY_VERSION = "unattended-stall-policy-v1";
+var UNATTENDED_STALL_POLICY_FILENAME = "unattended-stall-policy.json";
+var UNATTENDED_STALL_POLICY_WORKSPACE_PATH = path5.join(
+  "config",
+  UNATTENDED_STALL_POLICY_FILENAME
+);
+var DEFAULTS_PATH2 = path5.join(
+  MODULE_DIR3,
+  "defaults",
+  UNATTENDED_STALL_POLICY_FILENAME
+);
+function isRecord4(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizePositiveInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+}
+function normalizeUnattendedStallPolicyOverrides(value) {
+  if (!isRecord4(value)) {
+    throw new Error("devory: unattended stall policy config must be a JSON object");
+  }
+  const overrides = {};
+  const keys = [
+    "heartbeat_stale_after_ms",
+    "heartbeat_missing_after_ms",
+    "progress_stalled_after_ms",
+    "waiting_progress_grace_ms",
+    "looping_event_window",
+    "looping_event_threshold",
+    "repeated_failure_without_progress_threshold"
+  ];
+  for (const key of keys) {
+    const normalized = normalizePositiveInteger(value[key]);
+    if (normalized !== void 0) {
+      overrides[key] = normalized;
+    }
+  }
+  return overrides;
+}
+function applyUnattendedStallPolicyOverrides(base, overrides) {
+  return {
+    ...base,
+    ...overrides,
+    version: UNATTENDED_STALL_POLICY_VERSION
+  };
+}
+function loadDefaultUnattendedStallPolicy() {
+  return JSON.parse(fs5.readFileSync(DEFAULTS_PATH2, "utf-8"));
+}
+function loadWorkspaceUnattendedStallPolicy(factoryRoot) {
+  const filePath = path5.join(factoryRoot, UNATTENDED_STALL_POLICY_WORKSPACE_PATH);
+  if (!fs5.existsSync(filePath))
+    return null;
+  return normalizeUnattendedStallPolicyOverrides(
+    JSON.parse(fs5.readFileSync(filePath, "utf-8"))
+  );
+}
+function resolveUnattendedStallPolicy(factoryRoot, runOverrides = {}) {
+  const base = loadDefaultUnattendedStallPolicy();
+  let policy = base;
+  const applied_layers = [
+    "shipped-defaults"
+  ];
+  let workspace_config_path = null;
+  if (factoryRoot) {
+    const workspace = loadWorkspaceUnattendedStallPolicy(factoryRoot);
+    if (workspace) {
+      policy = applyUnattendedStallPolicyOverrides(policy, workspace);
+      applied_layers.push("workspace-config");
+      workspace_config_path = path5.join(
+        factoryRoot,
+        UNATTENDED_STALL_POLICY_WORKSPACE_PATH
+      );
+    }
+  }
+  if (Object.keys(runOverrides).length > 0) {
+    policy = applyUnattendedStallPolicyOverrides(policy, runOverrides);
+    applied_layers.push("run-override");
+  }
+  return {
+    policy,
+    applied_layers,
+    workspace_config_path
+  };
+}
+
+// src/routing-input.ts
+var VALID_ROUTING_EXECUTION_PROFILES = [
+  "balanced",
+  "implementation",
+  "analysis",
+  "review",
+  "documentation"
+];
+var VALID_ROUTING_CONTEXT_INTENSITIES = [
+  "low",
+  "medium",
+  "high"
+];
+var VALID_ROUTING_PRIORITY_LEVELS = ["low", "medium", "high"];
+function normalizeString(value) {
+  if (typeof value !== "string")
+    return null;
+  const normalized = value.trim();
+  return normalized === "" ? null : normalized;
+}
+function normalizeStringList(value) {
+  if (!Array.isArray(value))
+    return [];
+  return [...new Set(
+    value.filter((item) => typeof item === "string").map((item) => item.trim()).filter((item) => item !== "")
+  )];
+}
+function normalizeEnumValue(value, validValues) {
+  const normalized = normalizeString(value);
+  if (normalized === null)
+    return null;
+  return validValues.includes(normalized) ? normalized : null;
+}
+function normalizeRoutingInput(meta, context = {}) {
+  const executionProfile = normalizeEnumValue(
+    meta.execution_profile,
+    VALID_ROUTING_EXECUTION_PROFILES
+  );
+  return {
+    task_id: normalizeString(meta.id),
+    task_title: normalizeString(meta.title),
+    task_type: normalizeString(meta.type)?.toLowerCase() ?? null,
+    project: normalizeString(meta.project),
+    work_role: normalizeString(context.work_role) ?? normalizeString(context.stage) ?? executionProfile,
+    execution_profile: executionProfile,
+    execution_mode: normalizeString(context.execution_mode),
+    stage: normalizeString(context.stage),
+    cost_environment: normalizeString(context.cost_environment),
+    required_capabilities: normalizeStringList(meta.required_capabilities),
+    preferred_capabilities: normalizeStringList(meta.preferred_capabilities),
+    preferred_models: normalizeStringList(meta.preferred_models),
+    disallowed_models: normalizeStringList(meta.disallowed_models),
+    context_intensity: normalizeEnumValue(
+      meta.context_intensity,
+      VALID_ROUTING_CONTEXT_INTENSITIES
+    ),
+    quality_priority: normalizeEnumValue(
+      meta.quality_priority,
+      VALID_ROUTING_PRIORITY_LEVELS
+    ),
+    speed_priority: normalizeEnumValue(
+      meta.speed_priority,
+      VALID_ROUTING_PRIORITY_LEVELS
+    ),
+    max_cost_tier: normalizeString(meta.max_cost_tier),
+    lane: normalizeString(meta.lane),
+    repo_area: normalizeString(meta.repo_area),
+    repo: normalizeString(meta.repo),
+    branch: normalizeString(meta.branch),
+    decomposition_hint: normalizeString(meta.decomposition_hint),
+    language: null,
+    framework: null,
+    complexity: null,
+    risk_level: null,
+    privacy_sensitivity: null,
+    environment_constraints: {
+      fallback_only: context.fallback_only === true,
+      retry_attempt: typeof context.retry_attempt === "number" && Number.isFinite(context.retry_attempt) ? context.retry_attempt : null,
+      resumed_from_run_id: normalizeString(context.resumed_from_run_id),
+      factory_read_only: context.factory_read_only === true
+    }
+  };
+}
+
+// src/routing-decision.ts
+var ROUTING_DECISION_VERSION = "routing-decision-v1";
+function slug(value) {
+  return value.replace(/[^a-z0-9-]+/gi, "-").replace(/^-+|-+$/g, "").toLowerCase();
+}
+function buildRoutingDecisionId(linkage) {
+  const parts = [
+    "route",
+    linkage.task_id ? slug(linkage.task_id) : "task",
+    linkage.run_id ? slug(linkage.run_id) : "run",
+    linkage.pipeline_run_id ? slug(linkage.pipeline_run_id) : "pipeline",
+    linkage.stage_name ? slug(linkage.stage_name) : "stage",
+    linkage.attempt_number === null || linkage.attempt_number === void 0 ? "attempt-na" : `attempt-${linkage.attempt_number}`
+  ];
+  return parts.join("-");
+}
+function attachRoutingDecisionLinkage(decision, linkage = {}, normalizedInput = null) {
+  const resolvedLinkage = {
+    decision_id: typeof linkage.decision_id === "string" && linkage.decision_id !== "" ? linkage.decision_id : buildRoutingDecisionId(linkage),
+    task_id: linkage.task_id ?? null,
+    run_id: linkage.run_id ?? null,
+    pipeline_run_id: linkage.pipeline_run_id ?? null,
+    stage_name: linkage.stage_name ?? null,
+    attempt_number: linkage.attempt_number ?? null
+  };
+  return {
+    ...decision,
+    version: ROUTING_DECISION_VERSION,
+    linkage: resolvedLinkage,
+    normalized_input: normalizedInput
+  };
+}
+
+// src/routing-evaluation.ts
+function buildRoutingOutcomeEvaluation(input) {
+  const validationOutcome = input.validation_outcome ?? null;
+  const reviewOutcome = input.review_outcome ?? null;
+  const manualIntervention = input.manual_intervention ?? null;
+  const evidenceCount = [validationOutcome, reviewOutcome, manualIntervention].filter(
+    (value) => value !== null
+  ).length;
+  const evidenceStatus = evidenceCount === 0 ? "missing" : evidenceCount === 3 ? "complete" : "partial";
+  let evaluationStatus = "inconclusive";
+  if (reviewOutcome === "approved") {
+    evaluationStatus = "successful";
+  } else if (reviewOutcome === "send-back" || reviewOutcome === "blocked" || reviewOutcome === "needs-human-edits" || validationOutcome === "failed") {
+    evaluationStatus = "unsuccessful";
+  } else if (validationOutcome === "passed" && manualIntervention === "performed") {
+    evaluationStatus = "successful";
+  }
+  return {
+    evaluation_status: evaluationStatus,
+    evidence_status: evidenceStatus,
+    validation_outcome: validationOutcome,
+    review_outcome: reviewOutcome,
+    manual_intervention: manualIntervention,
+    retry_count: input.retry_count ?? null,
+    runtime_ms: input.runtime_ms ?? null,
+    spend_units: input.spend_units ?? null,
+    total_tokens: input.total_tokens ?? null,
+    estimated_cost_usd: input.estimated_cost_usd ?? null,
+    review_artifact_path: input.review_artifact_path ?? null,
+    promotion_decision_path: input.promotion_decision_path ?? null,
+    source_artifacts: input.source_artifacts ?? [],
+    updated_at: input.updated_at ?? null
+  };
+}
+
+// src/human-question.ts
+var HUMAN_QUESTION_VERSION = "human-question-v1";
+var HUMAN_INTERRUPTION_POLICY_MAP = {
+  level_1: {
+    interruption_level: "level_1",
+    work_continues: true,
+    lane_pauses: false,
+    run_halts: false,
+    run_status: "running",
+    blocked_task_status: "blocked"
+  },
+  level_2: {
+    interruption_level: "level_2",
+    work_continues: true,
+    lane_pauses: true,
+    run_halts: false,
+    run_status: "paused_for_review",
+    blocked_task_status: "blocked"
+  },
+  level_3: {
+    interruption_level: "level_3",
+    work_continues: false,
+    lane_pauses: true,
+    run_halts: true,
+    run_status: "failed",
+    blocked_task_status: "blocked"
+  }
+};
+function buildHumanQuestionFixture(overrides = {}) {
+  const status = overrides.status ?? "open";
+  const createdAt = overrides.created_at ?? "2026-03-28T10:00:00.000Z";
+  const updatedAt = overrides.updated_at ?? createdAt;
+  return {
+    version: HUMAN_QUESTION_VERSION,
+    question_id: "hq-001",
+    task_id: "factory-136",
+    run_id: "orchestrator-run-001",
+    lane_id: "default",
+    status,
+    category: "execution-ambiguity",
+    summary: "Choose the safe fallback for the failing migration path.",
+    question_detail: "The planned migration may drop existing local state. Which fallback should Devory use?",
+    interruption_level: "level_2",
+    input_mode: "local-api",
+    fallback_behavior: "pause-affected-lane",
+    timeout_policy: {
+      timeout_seconds: 1800,
+      on_timeout: "assume-default"
+    },
+    options: [
+      {
+        id: "keep-current",
+        label: "Keep current behavior",
+        description: "Continue with the existing migration path."
+      },
+      {
+        id: "skip-migration",
+        label: "Skip migration",
+        description: "Bypass the migration and leave current state untouched."
+      }
+    ],
+    recommended_option_id: "skip-migration",
+    answer: status === "answered" ? {
+      selected_option_id: "skip-migration",
+      freeform_response: null,
+      answered_by: "operator",
+      answered_at: updatedAt
+    } : null,
+    created_at: createdAt,
+    updated_at: updatedAt,
+    audit_trail: status === "answered" ? [
+      {
+        event_type: "opened",
+        timestamp: createdAt,
+        actor: "devory",
+        note: "Question opened during execution."
+      },
+      {
+        event_type: "answered",
+        timestamp: updatedAt,
+        actor: "operator",
+        note: "Selected recommended safe fallback."
+      }
+    ] : [
+      {
+        event_type: "opened",
+        timestamp: createdAt,
+        actor: "devory",
+        note: "Question opened during execution."
+      }
+    ],
+    ...overrides
+  };
+}
+
+// src/human-question-artifact.ts
+var HUMAN_QUESTION_ARTIFACT_DIR = "human-questions";
+var HUMAN_QUESTION_ARTIFACT_TYPE = "human-question";
+function normaliseQuestionId(questionId) {
+  return questionId.trim().replace(/[^a-zA-Z0-9_-]+/g, "-");
+}
+function toFilesystemTimestamp(iso) {
+  return iso.replace(/[:.]/g, "-");
+}
+function buildHumanQuestionArtifactRelativePath(record) {
+  const taskScope = record.task_id?.trim() || "unscoped";
+  const timestamp2 = toFilesystemTimestamp(record.created_at);
+  const questionId = normaliseQuestionId(record.question_id);
+  return `${HUMAN_QUESTION_ARTIFACT_DIR}/${taskScope}/${timestamp2}-${questionId}.json`;
+}
+function serializeHumanQuestionArtifact(record) {
+  return `${JSON.stringify(record, null, 2)}
+`;
+}
+function isRecord5(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseHumanQuestionArtifact(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!isRecord5(parsed))
+    return null;
+  if (typeof parsed.question_id !== "string" || parsed.question_id.trim() === "")
+    return null;
+  if (typeof parsed.status !== "string" || parsed.status.trim() === "")
+    return null;
+  if (typeof parsed.created_at !== "string" || parsed.created_at.trim() === "")
+    return null;
+  if (typeof parsed.updated_at !== "string" || parsed.updated_at.trim() === "")
+    return null;
+  return parsed;
+}
+function extractHumanQuestionArtifactMetadata(raw) {
+  const record = parseHumanQuestionArtifact(raw);
+  if (!record)
+    return null;
+  return {
+    question_id: record.question_id,
+    task_id: record.task_id,
+    run_id: record.run_id,
+    status: record.status,
+    created_at: record.created_at
+  };
+}
+
+// src/human-question-event.ts
+var HUMAN_QUESTION_EVENT_VERSION = "human-question-event-v1";
+var HUMAN_QUESTION_EVENT_ARTIFACT_DIR = "human-question-events";
+var HUMAN_QUESTION_DIGEST_VERSION = "human-question-digest-v1";
+var HUMAN_QUESTION_DIGEST_ARTIFACT_DIR = "human-question-digests";
+function toFilesystemTimestamp2(iso) {
+  return iso.replace(/[:.]/g, "-");
+}
+function normaliseId(value) {
+  return value.trim().replace(/[^a-zA-Z0-9_-]+/g, "-");
+}
+function answerStateFromStatus(status) {
+  if (status === "answered")
+    return "answered";
+  if (status === "dismissed")
+    return "dismissed";
+  if (status === "expired")
+    return "expired";
+  return "waiting";
+}
+function buildHumanQuestionLifecycleEvent(input) {
+  return {
+    version: HUMAN_QUESTION_EVENT_VERSION,
+    event_id: `${input.question.question_id}-${input.event_type}-${toFilesystemTimestamp2(input.timestamp)}`,
+    event_type: input.event_type,
+    question_id: input.question.question_id,
+    task_id: input.question.task_id,
+    run_id: input.question.run_id,
+    lane_id: input.question.lane_id,
+    status: input.question.status,
+    interruption_level: input.question.interruption_level,
+    fallback_behavior: input.question.fallback_behavior,
+    summary: input.question.summary,
+    timestamp: input.timestamp,
+    answer_state: answerStateFromStatus(input.question.status),
+    selected_option_id: input.question.answer?.selected_option_id ?? null,
+    blocked_task_id: input.blocked_task_id ?? input.question.task_id ?? null,
+    resumed_run_id: input.resumed_run_id ?? null,
+    resulting_task_stage: input.resulting_task_stage ?? null,
+    note: input.note ?? null
+  };
+}
+function buildHumanQuestionLifecycleEventRelativePath(event) {
+  const timestamp2 = toFilesystemTimestamp2(event.timestamp);
+  return `${HUMAN_QUESTION_EVENT_ARTIFACT_DIR}/${timestamp2}-${normaliseId(event.question_id)}-${event.event_type}.json`;
+}
+function serializeHumanQuestionLifecycleEvent(event) {
+  return `${JSON.stringify(event, null, 2)}
+`;
+}
+function isRecord6(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseHumanQuestionLifecycleEvent(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!isRecord6(parsed))
+    return null;
+  if (typeof parsed.event_id !== "string" || typeof parsed.question_id !== "string")
+    return null;
+  if (typeof parsed.event_type !== "string" || typeof parsed.timestamp !== "string")
+    return null;
+  return parsed;
+}
+function buildHumanQuestionDigest(questions, generatedAt) {
+  const openQuestions = questions.filter((question) => question.status === "open").sort((left, right) => left.created_at.localeCompare(right.created_at));
+  const entries = openQuestions.map((question) => ({
+    question_id: question.question_id,
+    task_id: question.task_id,
+    run_id: question.run_id,
+    lane_id: question.lane_id,
+    interruption_level: question.interruption_level,
+    category: question.category,
+    summary: question.summary,
+    created_at: question.created_at,
+    age_minutes: Math.max(
+      0,
+      Math.floor(
+        (new Date(generatedAt).getTime() - new Date(question.created_at).getTime()) / 6e4
+      )
+    )
+  }));
+  const by_interruption_level = {};
+  const by_run_id = {};
+  const by_lane_id = {};
+  for (const entry of entries) {
+    by_interruption_level[entry.interruption_level] = (by_interruption_level[entry.interruption_level] ?? 0) + 1;
+    by_run_id[entry.run_id ?? "unscoped"] = (by_run_id[entry.run_id ?? "unscoped"] ?? 0) + 1;
+    by_lane_id[entry.lane_id ?? "unscoped"] = (by_lane_id[entry.lane_id ?? "unscoped"] ?? 0) + 1;
+  }
+  return {
+    version: HUMAN_QUESTION_DIGEST_VERSION,
+    generated_at: generatedAt,
+    total_open_questions: entries.length,
+    by_interruption_level,
+    by_run_id,
+    by_lane_id,
+    entries
+  };
+}
+function buildHumanQuestionDigestRelativePath(generatedAt) {
+  return `${HUMAN_QUESTION_DIGEST_ARTIFACT_DIR}/${toFilesystemTimestamp2(generatedAt)}-digest.json`;
+}
+function serializeHumanQuestionDigest(digest) {
+  return `${JSON.stringify(digest, null, 2)}
+`;
+}
+function renderHumanQuestionDigestMarkdown(digest) {
+  const lines = [
+    "---",
+    `version: ${digest.version}`,
+    `generated_at: ${digest.generated_at}`,
+    `total_open_questions: ${digest.total_open_questions}`,
+    "---",
+    "",
+    "# Human Question Digest",
+    "",
+    `Open questions: ${digest.total_open_questions}`,
+    "",
+    "## Open Questions",
+    ""
+  ];
+  if (digest.entries.length === 0) {
+    lines.push("- None");
+  } else {
+    for (const entry of digest.entries) {
+      lines.push(
+        `- ${entry.question_id} \xB7 ${entry.interruption_level} \xB7 ${entry.summary} \xB7 age ${entry.age_minutes}m \xB7 run ${entry.run_id ?? "unscoped"} \xB7 lane ${entry.lane_id ?? "unscoped"}`
+      );
+    }
+  }
+  lines.push("", "## By Interruption Level", "");
+  if (Object.keys(digest.by_interruption_level).length === 0) {
+    lines.push("- None");
+  } else {
+    for (const [key, count] of Object.entries(digest.by_interruption_level)) {
+      lines.push(`- ${key}: ${count}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+
+// src/human-interruption-policy.ts
+var fs6 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
+var import_url4 = require("url");
+var import_meta4 = {};
+var MODULE_DIR4 = typeof __dirname === "string" ? __dirname : path6.dirname((0, import_url4.fileURLToPath)(import_meta4.url));
+var HUMAN_INTERRUPTION_POLICY_VERSION = "human-interruption-policy-v1";
+var HUMAN_INTERRUPTION_POLICY_FILENAME = "human-interruption-policy.json";
+var HUMAN_INTERRUPTION_POLICY_WORKSPACE_PATH = path6.join(
+  "config",
+  HUMAN_INTERRUPTION_POLICY_FILENAME
+);
+var VALID_HUMAN_NOTIFICATION_MODES = ["immediate", "digest"];
+var VALID_HUMAN_POLICY_THRESHOLD_KEYS = [
+  "ambiguity",
+  "confirmation",
+  "approval",
+  "destructive_change",
+  "credentials",
+  "external_side_effect"
+];
+var DEFAULTS_PATH3 = path6.join(MODULE_DIR4, "defaults", HUMAN_INTERRUPTION_POLICY_FILENAME);
+var VALID_INTERRUPTION_LEVELS = ["level_1", "level_2", "level_3"];
+var VALID_INPUT_MODES = ["local-api", "cli", "digest"];
+var VALID_FALLBACK_BEHAVIORS = [
+  "continue-other-work",
+  "pause-affected-lane",
+  "halt-run",
+  "assume-default",
+  "skip-task"
+];
+function isRecord7(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeEnum(value, validValues) {
+  if (typeof value !== "string")
+    return null;
+  const normalized = value.trim();
+  return validValues.includes(normalized) ? normalized : null;
+}
+function normalizePositiveInteger2(value) {
+  if (typeof value === "number" && Number.isInteger(value) && value > 0) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number.parseInt(value.trim(), 10);
+    if (Number.isInteger(parsed) && parsed > 0)
+      return parsed;
+  }
+  return null;
+}
+function normalizeNullablePositiveInteger(value) {
+  if (value === null)
+    return null;
+  const normalized = normalizePositiveInteger2(value);
+  return normalized ?? void 0;
+}
+function normalizeInputModes(value) {
+  if (!Array.isArray(value))
+    return null;
+  const normalized = value.map((item) => normalizeEnum(item, VALID_INPUT_MODES)).filter((item) => item !== null);
+  return normalized.length > 0 ? [...new Set(normalized)] : null;
+}
+function normalizeHumanInterruptionPolicyOverrides(value) {
+  if (!isRecord7(value)) {
+    throw new Error("devory: human interruption policy config must be a JSON object");
+  }
+  const overrides = {};
+  const defaultInterruptionLevel = normalizeEnum(
+    value.default_interruption_level,
+    VALID_INTERRUPTION_LEVELS
+  );
+  if (defaultInterruptionLevel) {
+    overrides.default_interruption_level = defaultInterruptionLevel;
+  }
+  const defaultInputMode = normalizeEnum(value.default_input_mode, VALID_INPUT_MODES);
+  if (defaultInputMode) {
+    overrides.default_input_mode = defaultInputMode;
+  }
+  const allowedInputModes = normalizeInputModes(value.allowed_input_modes);
+  if (allowedInputModes) {
+    overrides.allowed_input_modes = allowedInputModes;
+  }
+  const defaultFallbackBehavior = normalizeEnum(
+    value.default_fallback_behavior,
+    VALID_FALLBACK_BEHAVIORS
+  );
+  if (defaultFallbackBehavior) {
+    overrides.default_fallback_behavior = defaultFallbackBehavior;
+  }
+  const timeoutSeconds = normalizePositiveInteger2(value.timeout_seconds);
+  if (timeoutSeconds !== null) {
+    overrides.timeout_seconds = timeoutSeconds;
+  }
+  const timeoutOnExpiry = normalizeEnum(value.timeout_on_expiry, VALID_FALLBACK_BEHAVIORS);
+  if (timeoutOnExpiry) {
+    overrides.timeout_on_expiry = timeoutOnExpiry;
+  }
+  const notificationMode = normalizeEnum(value.notification_mode, VALID_HUMAN_NOTIFICATION_MODES);
+  if (notificationMode) {
+    overrides.notification_mode = notificationMode;
+  }
+  const digestCadenceMinutes = normalizeNullablePositiveInteger(value.digest_cadence_minutes);
+  if (digestCadenceMinutes !== void 0) {
+    overrides.digest_cadence_minutes = digestCadenceMinutes;
+  }
+  if (isRecord7(value.interruption_thresholds)) {
+    const thresholdOverrides = {};
+    for (const key of VALID_HUMAN_POLICY_THRESHOLD_KEYS) {
+      const normalized = normalizeEnum(value.interruption_thresholds[key], VALID_INTERRUPTION_LEVELS);
+      if (normalized) {
+        thresholdOverrides[key] = normalized;
+      }
+    }
+    if (Object.keys(thresholdOverrides).length > 0) {
+      overrides.interruption_thresholds = thresholdOverrides;
+    }
+  }
+  return overrides;
+}
+function applyHumanInterruptionPolicyOverrides(base, overrides) {
+  const policy = {
+    ...base,
+    interruption_thresholds: {
+      ...base.interruption_thresholds,
+      ...overrides.interruption_thresholds
+    }
+  };
+  if (overrides.default_interruption_level) {
+    policy.default_interruption_level = overrides.default_interruption_level;
+  }
+  if (overrides.default_input_mode) {
+    policy.default_input_mode = overrides.default_input_mode;
+  }
+  if (overrides.allowed_input_modes) {
+    policy.allowed_input_modes = overrides.allowed_input_modes;
+  }
+  if (overrides.default_fallback_behavior) {
+    policy.default_fallback_behavior = overrides.default_fallback_behavior;
+  }
+  if (overrides.timeout_seconds !== void 0) {
+    policy.timeout_seconds = overrides.timeout_seconds;
+  }
+  if (overrides.timeout_on_expiry) {
+    policy.timeout_on_expiry = overrides.timeout_on_expiry;
+  }
+  if (overrides.notification_mode) {
+    policy.notification_mode = overrides.notification_mode;
+  }
+  if (overrides.digest_cadence_minutes !== void 0) {
+    policy.digest_cadence_minutes = overrides.digest_cadence_minutes;
+  }
+  if (!policy.allowed_input_modes.includes(policy.default_input_mode)) {
+    policy.allowed_input_modes = [...policy.allowed_input_modes, policy.default_input_mode];
+  }
+  if (policy.notification_mode === "immediate") {
+    policy.digest_cadence_minutes = null;
+  }
+  return policy;
+}
+function loadDefaultHumanInterruptionPolicy() {
+  const raw = fs6.readFileSync(DEFAULTS_PATH3, "utf-8");
+  const parsed = JSON.parse(raw);
+  const normalized = normalizeHumanInterruptionPolicyOverrides(parsed);
+  const base = {
+    version: HUMAN_INTERRUPTION_POLICY_VERSION,
+    default_interruption_level: "level_1",
+    default_input_mode: "local-api",
+    allowed_input_modes: ["local-api", "cli", "digest"],
+    default_fallback_behavior: "continue-other-work",
+    timeout_seconds: 1800,
+    timeout_on_expiry: "assume-default",
+    notification_mode: "digest",
+    digest_cadence_minutes: 30,
+    interruption_thresholds: {
+      ambiguity: "level_1",
+      confirmation: "level_1",
+      approval: "level_2",
+      destructive_change: "level_3",
+      credentials: "level_3",
+      external_side_effect: "level_2"
+    }
+  };
+  return applyHumanInterruptionPolicyOverrides(base, normalized);
+}
+function loadWorkspaceHumanInterruptionPolicy(factoryRoot) {
+  const filePath = path6.join(factoryRoot, HUMAN_INTERRUPTION_POLICY_WORKSPACE_PATH);
+  if (!fs6.existsSync(filePath)) {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(fs6.readFileSync(filePath, "utf-8"));
+  } catch (error) {
+    throw new Error(
+      `devory: failed to parse ${HUMAN_INTERRUPTION_POLICY_WORKSPACE_PATH}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  return normalizeHumanInterruptionPolicyOverrides(parsed);
+}
+function getTaskHumanInterruptionPolicyOverrides(meta) {
+  const overrides = {};
+  const defaultInterruptionLevel = normalizeEnum(
+    meta.human_default_interruption_level,
+    VALID_INTERRUPTION_LEVELS
+  );
+  if (defaultInterruptionLevel) {
+    overrides.default_interruption_level = defaultInterruptionLevel;
+  }
+  const defaultInputMode = normalizeEnum(meta.human_default_input_mode, VALID_INPUT_MODES);
+  if (defaultInputMode) {
+    overrides.default_input_mode = defaultInputMode;
+  }
+  const allowedInputModes = normalizeInputModes(meta.human_allowed_input_modes);
+  if (allowedInputModes) {
+    overrides.allowed_input_modes = allowedInputModes;
+  }
+  const defaultFallbackBehavior = normalizeEnum(
+    meta.human_default_fallback_behavior,
+    VALID_FALLBACK_BEHAVIORS
+  );
+  if (defaultFallbackBehavior) {
+    overrides.default_fallback_behavior = defaultFallbackBehavior;
+  }
+  const timeoutSeconds = normalizePositiveInteger2(meta.human_timeout_seconds);
+  if (timeoutSeconds !== null) {
+    overrides.timeout_seconds = timeoutSeconds;
+  }
+  const timeoutOnExpiry = normalizeEnum(meta.human_timeout_on_expiry, VALID_FALLBACK_BEHAVIORS);
+  if (timeoutOnExpiry) {
+    overrides.timeout_on_expiry = timeoutOnExpiry;
+  }
+  const notificationMode = normalizeEnum(
+    meta.human_notification_mode,
+    VALID_HUMAN_NOTIFICATION_MODES
+  );
+  if (notificationMode) {
+    overrides.notification_mode = notificationMode;
+  }
+  const digestCadenceMinutes = normalizeNullablePositiveInteger(meta.human_digest_cadence_minutes);
+  if (digestCadenceMinutes !== void 0) {
+    overrides.digest_cadence_minutes = digestCadenceMinutes;
+  }
+  const thresholdOverrides = {};
+  for (const key of VALID_HUMAN_POLICY_THRESHOLD_KEYS) {
+    const fieldName = `human_threshold_${key}`;
+    const normalized = normalizeEnum(meta[fieldName], VALID_INTERRUPTION_LEVELS);
+    if (normalized) {
+      thresholdOverrides[key] = normalized;
+    }
+  }
+  if (Object.keys(thresholdOverrides).length > 0) {
+    overrides.interruption_thresholds = thresholdOverrides;
+  }
+  return overrides;
+}
+function resolveHumanInterruptionPolicy(factoryRoot, meta = {}) {
+  let policy = loadDefaultHumanInterruptionPolicy();
+  const appliedLayers = ["shipped-defaults"];
+  const workspaceConfigPath = path6.join(factoryRoot, HUMAN_INTERRUPTION_POLICY_WORKSPACE_PATH);
+  const workspaceOverrides = loadWorkspaceHumanInterruptionPolicy(factoryRoot);
+  if (workspaceOverrides) {
+    policy = applyHumanInterruptionPolicyOverrides(policy, workspaceOverrides);
+    appliedLayers.push("workspace-config");
+  }
+  const taskOverrides = getTaskHumanInterruptionPolicyOverrides(meta);
+  if (Object.keys(taskOverrides).length > 0) {
+    policy = applyHumanInterruptionPolicyOverrides(policy, taskOverrides);
+    appliedLayers.push("task-frontmatter");
+  }
+  return {
+    policy,
+    applied_layers: appliedLayers,
+    workspace_config_path: fs6.existsSync(workspaceConfigPath) ? workspaceConfigPath : null
+  };
+}
+
+// src/slack-notification.ts
+var SLACK_NOTIFICATION_CONFIG_VERSION = "slack-notification-config-v1";
+var VALID_SLACK_TRANSPORT_KINDS = ["webhook", "bot-token"];
+var VALID_SLACK_DELIVERY_MODES = [
+  "suppressed",
+  "digest",
+  "immediate",
+  "urgent"
+];
+var VALID_SLACK_DIGEST_GROUP_BY = [
+  "interruption_level",
+  "run",
+  "lane",
+  "age"
+];
+function isRecord8(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeString2(value) {
+  if (typeof value !== "string")
+    return null;
+  const normalized = value.trim();
+  return normalized === "" ? null : normalized;
+}
+function normalizeBoolean(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function normalizePositiveInteger3(value, fallback) {
+  if (value === null)
+    return null;
+  if (typeof value === "number" && Number.isInteger(value) && value > 0)
+    return value;
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number.parseInt(value.trim(), 10);
+    if (Number.isInteger(parsed) && parsed > 0)
+      return parsed;
+  }
+  return fallback;
+}
+function normalizeStringArray(value, fallback) {
+  if (!Array.isArray(value))
+    return [...fallback];
+  const normalized = value.map((entry) => normalizeString2(entry)).filter((entry) => entry !== null);
+  return normalized.length > 0 ? [...new Set(normalized)] : [...fallback];
+}
+function normalizeLevel(value, fallback) {
+  return value === "level_1" || value === "level_2" || value === "level_3" ? value : fallback;
+}
+function normalizeDeliveryMode(value, fallback) {
+  return value === "suppressed" || value === "digest" || value === "immediate" || value === "urgent" ? value : fallback;
+}
+function normalizeDigestGroupBy(value, fallback) {
+  if (!Array.isArray(value))
+    return [...fallback];
+  const normalized = value.filter(
+    (entry) => entry === "interruption_level" || entry === "run" || entry === "lane" || entry === "age"
+  );
+  return normalized.length > 0 ? [...new Set(normalized)] : [...fallback];
+}
+function normalizeTransport(value) {
+  if (!isRecord8(value)) {
+    return { kind: "webhook", webhook_url_env: "SLACK_WEBHOOK_URL" };
+  }
+  if (value.kind === "bot-token") {
+    return {
+      kind: "bot-token",
+      bot_token_env: normalizeString2(value.bot_token_env) ?? "SLACK_BOT_TOKEN"
+    };
+  }
+  return {
+    kind: "webhook",
+    webhook_url_env: normalizeString2(value.webhook_url_env) ?? "SLACK_WEBHOOK_URL"
+  };
+}
+function normalizeSlackNotificationConfig(value) {
+  if (!isRecord8(value)) {
+    throw new Error("devory: slack notification config must be a JSON object");
+  }
+  const transport = normalizeTransport(value.transport);
+  const defaultChannel = normalizeString2(value.default_channel) ?? "#devory-alerts";
+  const dmRouting = isRecord8(value.dm_routing) ? value.dm_routing : {};
+  const severityRouting = isRecord8(value.severity_routing) ? value.severity_routing : {};
+  const severityLevelModes = isRecord8(severityRouting.level_modes) ? severityRouting.level_modes : {};
+  const digest = isRecord8(value.digest) ? value.digest : {};
+  return {
+    version: SLACK_NOTIFICATION_CONFIG_VERSION,
+    enabled: normalizeBoolean(value.enabled, true),
+    transport,
+    default_channel: defaultChannel,
+    dm_routing: {
+      enabled: normalizeBoolean(dmRouting.enabled, false),
+      resolver_fields: normalizeStringArray(dmRouting.resolver_fields, [
+        "slack_user_id",
+        "owner",
+        "assignee"
+      ]),
+      user_map: isRecord8(dmRouting.user_map) ? Object.fromEntries(
+        Object.entries(dmRouting.user_map).map(([key, mapped]) => [key.trim(), normalizeString2(mapped)]).filter((entry) => entry[0] !== "" && entry[1] !== null)
+      ) : {},
+      fallback_to_default_channel: normalizeBoolean(dmRouting.fallback_to_default_channel, true)
+    },
+    severity_routing: {
+      minimum_level: normalizeLevel(severityRouting.minimum_level, "level_1"),
+      level_modes: {
+        level_1: normalizeDeliveryMode(severityLevelModes["level_1"], "digest"),
+        level_2: normalizeDeliveryMode(severityLevelModes["level_2"], "immediate"),
+        level_3: normalizeDeliveryMode(severityLevelModes["level_3"], "urgent")
+      }
+    },
+    digest: {
+      enabled: normalizeBoolean(digest.enabled, true),
+      default_channel: normalizeString2(digest.default_channel),
+      cadence_minutes: normalizePositiveInteger3(digest.cadence_minutes, 30),
+      max_entries: normalizePositiveInteger3(digest.max_entries, 20) ?? 20,
+      group_by: normalizeDigestGroupBy(digest.group_by, ["interruption_level", "run"])
+    }
   };
-  return `[devory] ${featureLabel[feature]} requires a Pro license \u2014 set DEVORY_LICENSE_KEY or create .devory/license to upgrade. This setting will be ignored on Core tier.`;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ESCALATION_REASONS,
+  EXECUTION_POLICY_FILENAME,
+  EXECUTION_POLICY_VERSION,
+  EXECUTION_POLICY_WORKSPACE_PATH,
+  HUMAN_INTERRUPTION_POLICY_FILENAME,
+  HUMAN_INTERRUPTION_POLICY_MAP,
+  HUMAN_INTERRUPTION_POLICY_VERSION,
+  HUMAN_INTERRUPTION_POLICY_WORKSPACE_PATH,
+  HUMAN_QUESTION_ARTIFACT_DIR,
+  HUMAN_QUESTION_ARTIFACT_TYPE,
+  HUMAN_QUESTION_DIGEST_ARTIFACT_DIR,
+  HUMAN_QUESTION_DIGEST_VERSION,
+  HUMAN_QUESTION_EVENT_ARTIFACT_DIR,
+  HUMAN_QUESTION_EVENT_VERSION,
+  HUMAN_QUESTION_VERSION,
+  PLANNING_DRAFT_COMMIT_STATES,
+  PLANNING_DRAFT_CONTRACT_VERSION,
+  PLANNING_DRAFT_KINDS,
+  PLANNING_DRAFT_PERSISTENCE_MODES,
+  PLANNING_DRAFT_VALIDATION_STATUSES,
+  PROGRESS_EVENT_CATEGORIES,
+  REQUIRED_FIELDS,
+  RESUMABLE_RUN_STATUSES,
+  REVIEW_CONTROL_ACTIONS,
+  REVIEW_CONTROL_CONTRACT_VERSION,
+  REVIEW_CONTROL_MECHANISMS,
+  REVIEW_QUEUE_ITEM_KINDS,
+  REVIEW_QUEUE_RUN_STATUSES,
+  REVIEW_QUEUE_TASK_STAGES,
+  REVIEW_QUEUE_TRIAGE_STAGES,
+  ROUTING_DECISION_VERSION,
+  RUN_LEDGER_VERSION,
+  SLACK_NOTIFICATION_CONFIG_VERSION,
   STANDARDS_FILENAME,
+  TASK_DRAFT_BODY_SECTION_ORDER,
+  TASK_DRAFT_COMMIT_STAGES,
+  TASK_DRAFT_OPTIONAL_FRONTMATTER_FIELDS,
+  TASK_DRAFT_RENDER_CONTRACT_VERSION,
+  TASK_DRAFT_REQUIRED_FRONTMATTER_FIELDS,
+  TASK_MARKDOWN_FRONTMATTER_ORDER,
+  TASK_MARKDOWN_RENDERER_VERSION,
+  TASK_MARKDOWN_SECTION_ORDER,
+  TASK_REVIEW_ACTIONS,
+  TASK_REVIEW_ACTION_STAGE_MAP,
+  UNATTENDED_CHECKPOINT_TRIGGERS,
+  UNATTENDED_CHECKPOINT_VERSION,
+  UNATTENDED_EXECUTION_CONTRACT_VERSION,
+  UNATTENDED_RUN_STATUSES,
+  UNATTENDED_STALL_POLICY_FILENAME,
+  UNATTENDED_STALL_POLICY_VERSION,
+  UNATTENDED_STALL_POLICY_WORKSPACE_PATH,
+  VALID_HUMAN_NOTIFICATION_MODES,
+  VALID_HUMAN_POLICY_THRESHOLD_KEYS,
+  VALID_POLICY_ESCALATION_BEHAVIORS,
+  VALID_ROUTING_CONTEXT_INTENSITIES,
+  VALID_ROUTING_EXECUTION_PROFILES,
+  VALID_ROUTING_PRIORITY_LEVELS,
+  VALID_SLACK_DELIVERY_MODES,
+  VALID_SLACK_DIGEST_GROUP_BY,
+  VALID_SLACK_TRANSPORT_KINDS,
+  WORKER_HEALTH_STATUSES,
+  applyExecutionPolicyOverrides,
+  applyHumanInterruptionPolicyOverrides,
+  applyTaskDraftValidation,
+  applyTaskRoutingOutcomeEvaluation,
+  applyUnattendedStallPolicyOverrides,
+  attachRoutingDecisionLinkage,
+  buildEpicPlanningDraft,
+  buildEpicPlanningDraftFixture,
+  buildExecutionPolicyInjection,
+  buildHumanQuestionArtifactRelativePath,
+  buildHumanQuestionDigest,
+  buildHumanQuestionDigestRelativePath,
+  buildHumanQuestionFixture,
+  buildHumanQuestionLifecycleEvent,
+  buildHumanQuestionLifecycleEventRelativePath,
+  buildMinimalTaskDraftFixture,
+  buildPlanningDraftArtifactPath,
+  buildPlanningDraftStorageRelativePath,
+  buildRichTaskDraftFixture,
+  buildRoutingDecisionId,
+  buildRoutingOutcomeEvaluation,
+  buildRunAttentionQueueItem,
+  buildTaskDraftRenderFixture,
+  buildTaskDraftTargetPath,
+  buildTaskPlanningDraftFixture,
+  buildTaskReviewQueueItem,
+  buildTaskTriageQueueItem,
+  clearLicenseCache,
+  clearLicenseToken,
   detectTier,
+  extractHumanQuestionArtifactMetadata,
   factoryPaths,
   findFactoryContextDir,
+  getLicenseCacheFilePath,
+  getLicenseFilePath,
+  getLicenseStatus,
+  getSupportedReviewActions,
+  getTaskHumanInterruptionPolicyOverrides,
   isFeatureEnabled,
   loadBaseline,
+  loadDefaultExecutionPolicy,
+  loadDefaultHumanInterruptionPolicy,
+  loadDefaultUnattendedStallPolicy,
   loadStandards,
+  loadWorkspaceExecutionPolicy,
+  loadWorkspaceHumanInterruptionPolicy,
+  loadWorkspaceUnattendedStallPolicy,
   mergeStandards,
+  normalizeExecutionPolicyOverrides,
+  normalizeHumanInterruptionPolicyOverrides,
+  normalizePlanningDraft,
+  normalizeReviewQueueItem,
+  normalizeRoutingInput,
+  normalizeRunRecord,
+  normalizeSlackNotificationConfig,
+  normalizeTaskDraft,
+  normalizeTaskRecord,
+  normalizeUnattendedCheckpointArtifact,
+  normalizeUnattendedExecutionSnapshot,
+  normalizeUnattendedStallPolicyOverrides,
   parseFrontmatter,
+  parseHumanQuestionArtifact,
+  parseHumanQuestionLifecycleEvent,
+  renderHumanQuestionDigestMarkdown,
+  renderTaskDraftMarkdown,
+  renderTaskDraftTarget,
+  renderTaskMarkdown,
+  renderTaskMarkdownTarget,
+  renderTaskPlanningDraftTarget,
   resolveBaselinePath,
+  resolveExecutionPolicy,
   resolveFactoryEnvironment,
   resolveFactoryMode,
   resolveFactoryRoot,
+  resolveHumanInterruptionPolicy,
+  resolveUnattendedStallPolicy,
+  serializeHumanQuestionArtifact,
+  serializeHumanQuestionDigest,
+  serializeHumanQuestionLifecycleEvent,
+  serializePlanningDraft,
   serializeStandardsAsDoctrine,
-  tierGateMessage
+  tierGateMessage,
+  toPlanningDraftValidationRecord,
+  updateEpicPlanningDraft,
+  validateTask,
+  validateTaskBody,
+  validateTaskDraft,
+  validateTaskMarkdown,
+  writeLicenseToken
 });
 /*! Bundled license information: