@aaac/contracts 0.1.14 → 0.1.16

package/dist/{chunk-JWJLY3HJ.js → chunk-F57V745S.js}

@@ -1570,11 +1570,121 @@ async function writeGeneratedFiles(files, outputDir) {
 
 // src/cli/governance.ts
 import { createHash } from "crypto";
+import { existsSync as existsSync3 } from "fs";
+import { chmod, mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname6, join as join4, resolve as resolve4 } from "path";
+import { parse as parseYaml4 } from "yaml";
+import { z as z3 } from "zod";
+
+// src/cli/observ-config.ts
 import { existsSync as existsSync2 } from "fs";
-import { chmod, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import { dirname as dirname5, join as join3, resolve as resolve3 } from "path";
 import { parse as parseYaml3 } from "yaml";
 import { z as z2 } from "zod";
+var OBSERV_CONFIG_DIR = ".agent-logs/config";
+var EVENT_MAPPING_JSON = `${OBSERV_CONFIG_DIR}/event-mapping.json`;
+var ARTIFACT_LOOKUP_JSON = `${OBSERV_CONFIG_DIR}/artifact-lookup.json`;
+var TASK_PATTERNS_JSON = `${OBSERV_CONFIG_DIR}/task-patterns.json`;
+function generateTaskPatterns() {
+  return [
+    { tag_prefix: "DSL_TASK", field: "task.id" },
+    { tag_prefix: "AGENT_ROLE", field: "task.target_agent" },
+    { tag_prefix: "WORKFLOW_PHASE", field: "workflow.phase" }
+  ];
+}
+function generateArtifactLookup(artifactDeclarations) {
+  const patterns = [];
+  for (const decl of artifactDeclarations) {
+    for (const pattern of decl.path_patterns) {
+      patterns.push({ artifact_id: decl.artifact_id, pattern });
+    }
+  }
+  return patterns;
+}
+function extractEventMappingRules(parsed) {
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+    const obj = parsed;
+    const rules = obj.event_mapping ?? obj.mappings;
+    if (rules && typeof rules === "object") {
+      return rules;
+    }
+  }
+  return {};
+}
+var ArtifactContractsSchema = z2.object({
+  artifacts: z2.record(
+    z2.string(),
+    z2.object({ path_patterns: z2.array(z2.string()).optional() }).passthrough()
+  ).optional()
+});
+function parseArtifactDeclarations(parsed) {
+  const { artifacts } = ArtifactContractsSchema.parse(parsed ?? {});
+  if (!artifacts) return [];
+  const decls = [];
+  for (const [artifact_id, decl] of Object.entries(artifacts)) {
+    if (decl.path_patterns && decl.path_patterns.length > 0) {
+      decls.push({ artifact_id, path_patterns: decl.path_patterns });
+    }
+  }
+  return decls;
+}
+function serialize(value) {
+  return JSON.stringify(value, null, 2) + "\n";
+}
+async function writeJsonIfChanged(absPath, value) {
+  const serialized = serialize(value);
+  const existed = existsSync2(absPath);
+  const existing = existed ? await readFile2(absPath, "utf8") : void 0;
+  if (existing === serialized) {
+    return "unchanged";
+  }
+  await mkdir2(dirname5(absPath), { recursive: true });
+  await writeFile2(absPath, serialized, "utf8");
+  return existed ? "updated" : "created";
+}
+async function generateObservConfig(options) {
+  const root = resolve3(options.projectRoot);
+  const generated = [];
+  if (options.eventMapping) {
+    const bindingPath = resolve3(root, options.eventMapping);
+    if (existsSync2(bindingPath)) {
+      const parsed = parseYaml3(await readFile2(bindingPath, "utf8"));
+      const mappings = extractEventMappingRules(parsed);
+      const action = await writeJsonIfChanged(
+        join3(root, EVENT_MAPPING_JSON),
+        { mappings }
+      );
+      generated.push({ path: EVENT_MAPPING_JSON, action });
+    }
+  }
+  if (options.artifactContracts) {
+    const contractsPath = resolve3(root, options.artifactContracts);
+    if (existsSync2(contractsPath)) {
+      const parsed = parseYaml3(await readFile2(contractsPath, "utf8"));
+      const lookup = generateArtifactLookup(parseArtifactDeclarations(parsed));
+      const action = await writeJsonIfChanged(
+        join3(root, ARTIFACT_LOOKUP_JSON),
+        lookup
+      );
+      generated.push({ path: ARTIFACT_LOOKUP_JSON, action });
+    }
+  }
+  {
+    const action = await writeJsonIfChanged(
+      join3(root, TASK_PATTERNS_JSON),
+      generateTaskPatterns()
+    );
+    generated.push({ path: TASK_PATTERNS_JSON, action });
+  }
+  const lockEntries = generated.map((g) => ({
+    path: g.path,
+    type: "generated"
+  }));
+  return { generated, lockEntries };
+}
+
+// src/cli/governance.ts
 var MANAGED_BLOCK_START = "# >>> aaac-governance:managed (do not edit) >>>";
 var MANAGED_BLOCK_END = "# <<< aaac-governance:managed <<<";
 var GOVERNANCE_LOCK_PATH = ".agent-logs/governance-manifest.lock";
@@ -1582,44 +1692,45 @@ var DEFAULT_RECORDER = ".cursor/hooks/observ-record.sh";
 var DEFAULT_CURSOR_HOOKS_JSON = ".cursor/hooks.json";
 var DEFAULT_BINARY_DEST = "bin/aaac.js";
 var CURSOR_HOOKS_VERSION = 1;
-var EnvironmentsSchema = z2.object({
-  git: z2.object({ hooks: z2.array(z2.string()).optional() }).optional(),
-  cursor: z2.object({ hooks_json: z2.string().optional() }).optional()
+var EnvironmentsSchema = z3.object({
+  git: z3.object({ hooks: z3.array(z3.string()).optional() }).optional(),
+  cursor: z3.object({ hooks_json: z3.string().optional() }).optional()
 }).optional();
-var BindingsObservabilitySchema = z2.object({
-  event_mapping: z2.string().optional(),
-  recorder: z2.string().optional()
+var BindingsObservabilitySchema = z3.object({
+  event_mapping: z3.string().optional(),
+  recorder: z3.string().optional()
 }).optional();
-var BindingsSchema = z2.object({
+var BindingsSchema = z3.object({
   observability: BindingsObservabilitySchema,
-  hooks: z2.array(z2.string()).optional()
+  hooks: z3.array(z3.string()).optional()
 }).optional();
-var InitProjectConfigSchema = z2.object({
+var InitProjectConfigSchema = z3.object({
   environments: EnvironmentsSchema,
-  bindings: BindingsSchema
+  bindings: BindingsSchema,
+  artifacts: z3.string().optional()
 });
 async function loadInitConfig(configPath) {
-  const absPath = resolve3(configPath);
-  const raw = await readFile2(absPath, "utf8");
-  const parsed = parseYaml3(raw);
+  const absPath = resolve4(configPath);
+  const raw = await readFile3(absPath, "utf8");
+  const parsed = parseYaml4(raw);
   return InitProjectConfigSchema.parse(parsed ?? {});
 }
-var HookCommandSchema = z2.object({
-  command: z2.string(),
-  description: z2.string().optional()
+var HookCommandSchema = z3.object({
+  command: z3.string(),
+  description: z3.string().optional()
 });
-var HookBindingSchema = z2.object({
-  hooks: z2.record(z2.string(), z2.array(HookCommandSchema)).optional()
+var HookBindingSchema = z3.object({
+  hooks: z3.record(z3.string(), z3.array(HookCommandSchema)).optional()
 });
 async function loadHookBindings(projectRoot, bindingPaths) {
   const result = {};
   if (!bindingPaths?.length) return result;
-  const root = resolve3(projectRoot);
+  const root = resolve4(projectRoot);
   for (const bindingPath of bindingPaths) {
-    const absPath = resolve3(root, bindingPath);
-    if (!existsSync2(absPath)) continue;
-    const raw = await readFile2(absPath, "utf8");
-    const parsed = HookBindingSchema.parse(parseYaml3(raw) ?? {});
+    const absPath = resolve4(root, bindingPath);
+    if (!existsSync3(absPath)) continue;
+    const raw = await readFile3(absPath, "utf8");
+    const parsed = HookBindingSchema.parse(parseYaml4(raw) ?? {});
     if (!parsed.hooks) continue;
     for (const [hookName, commands] of Object.entries(parsed.hooks)) {
       const list = result[hookName] ?? [];
@@ -1746,44 +1857,58 @@ function buildGitHookBlock(hookName, recorder, gateCommands = []) {
   }
   return lines.join("\n");
 }
+var DEFAULT_CURSOR_HOOK_EVENTS = [
+  "sessionStart",
+  "sessionEnd",
+  "subagentStart",
+  "subagentStop",
+  "beforeSubmitPrompt",
+  "afterShellExecution",
+  "preToolUse",
+  "postToolUse",
+  "postToolUseFailure",
+  "afterFileEdit",
+  "preCompact",
+  "stop"
+];
 function buildDefaultCursorHooks(recorder) {
-  return [
-    { event: "beforeSubmitPrompt", command: `${recorder} beforeSubmitPrompt` },
-    { event: "afterShellExecution", command: `${recorder} afterShellExecution` }
-  ];
+  return DEFAULT_CURSOR_HOOK_EVENTS.map((event) => ({
+    event,
+    command: `${recorder} ${event}`
+  }));
 }
 async function ensureParentDir(filePath) {
-  await mkdir2(dirname5(filePath), { recursive: true });
+  await mkdir3(dirname6(filePath), { recursive: true });
 }
 async function readTextFileIfExists(filePath) {
-  if (!existsSync2(filePath)) return void 0;
-  return readFile2(filePath, "utf8");
+  if (!existsSync3(filePath)) return void 0;
+  return readFile3(filePath, "utf8");
 }
 async function writeGovernanceLock(projectRoot, entries) {
-  const lockPath = join3(projectRoot, GOVERNANCE_LOCK_PATH);
+  const lockPath = join4(projectRoot, GOVERNANCE_LOCK_PATH);
   const lock = {
     materialized_at: (/* @__PURE__ */ new Date()).toISOString(),
     entries
   };
   await ensureParentDir(lockPath);
-  await writeFile2(lockPath, JSON.stringify(lock, null, 2) + "\n", "utf8");
+  await writeFile3(lockPath, JSON.stringify(lock, null, 2) + "\n", "utf8");
   return GOVERNANCE_LOCK_PATH;
 }
 async function readGovernanceLock(projectRoot) {
-  const lockPath = join3(projectRoot, GOVERNANCE_LOCK_PATH);
-  if (!existsSync2(lockPath)) return void 0;
-  const raw = await readFile2(lockPath, "utf8");
+  const lockPath = join4(projectRoot, GOVERNANCE_LOCK_PATH);
+  if (!existsSync3(lockPath)) return void 0;
+  const raw = await readFile3(lockPath, "utf8");
   if (!raw.trim()) return void 0;
   return JSON.parse(raw);
 }
 async function materializeHooks(options) {
-  const projectRoot = resolve3(options.projectRoot);
+  const projectRoot = resolve4(options.projectRoot);
   const result = { materialized: [], lockEntries: [] };
   const recorder = options.observabilityBinding?.recorder ?? DEFAULT_RECORDER;
   if (options.environments.git?.hooks?.length) {
     for (const hookName of options.environments.git.hooks) {
-      const relPath = join3(".git/hooks", hookName);
-      const absPath = join3(projectRoot, relPath);
+      const relPath = join4(".git/hooks", hookName);
+      const absPath = join4(projectRoot, relPath);
       const blockContent = buildGitHookBlock(
         hookName,
         recorder,
@@ -1792,14 +1917,14 @@ async function materializeHooks(options) {
       const existing = await readTextFileIfExists(absPath) ?? "";
       const updated = injectManagedBlock(existing, blockContent);
       let action = "unchanged";
-      if (!existsSync2(absPath)) {
+      if (!existsSync3(absPath)) {
         action = "created";
       } else if (updated !== existing) {
         action = "updated";
       }
       if (action !== "unchanged") {
         await ensureParentDir(absPath);
-        await writeFile2(absPath, updated, "utf8");
+        await writeFile3(absPath, updated, "utf8");
         await chmod(absPath, 493);
       }
       result.materialized.push({ path: relPath, action });
@@ -1808,7 +1933,7 @@ async function materializeHooks(options) {
   }
   if (options.environments.cursor) {
     const rawHooksJsonValue = options.environments.cursor.hooks_json;
-    const hooksJsonPath = rawHooksJsonValue ? resolve3(projectRoot, rawHooksJsonValue) : join3(projectRoot, DEFAULT_CURSOR_HOOKS_JSON);
+    const hooksJsonPath = rawHooksJsonValue ? resolve4(projectRoot, rawHooksJsonValue) : join4(projectRoot, DEFAULT_CURSOR_HOOKS_JSON);
     const relPath = hooksJsonPath.startsWith(projectRoot + "/") ? hooksJsonPath.slice(projectRoot.length + 1) : DEFAULT_CURSOR_HOOKS_JSON;
     const newEntries = buildDefaultCursorHooks(recorder);
     const existingRaw = await readTextFileIfExists(hooksJsonPath);
@@ -1816,20 +1941,31 @@ async function materializeHooks(options) {
     const merged = mergeCursorHooks(existing, newEntries);
     const serialized = serializeCursorHooksFile(merged);
     let action = "unchanged";
-    if (!existsSync2(hooksJsonPath)) {
+    if (!existsSync3(hooksJsonPath)) {
       action = "created";
     } else if (serialized !== existingRaw) {
       action = "updated";
     }
     if (action !== "unchanged") {
       await ensureParentDir(hooksJsonPath);
-      await writeFile2(hooksJsonPath, serialized, "utf8");
+      await writeFile3(hooksJsonPath, serialized, "utf8");
     }
     result.materialized.push({ path: relPath, action });
     result.lockEntries.push({ path: relPath, type: "cursor-hook" });
   }
+  if (options.observabilityBinding) {
+    const { generated, lockEntries } = await generateObservConfig({
+      projectRoot,
+      eventMapping: options.observabilityBinding.event_mapping,
+      artifactContracts: options.artifactContracts
+    });
+    for (const g of generated) {
+      result.materialized.push({ path: g.path, action: g.action });
+    }
+    result.lockEntries.push(...lockEntries);
+  }
   if (result.lockEntries.length > 0) {
-    const lockExisted = existsSync2(join3(projectRoot, GOVERNANCE_LOCK_PATH));
+    const lockExisted = existsSync3(join4(projectRoot, GOVERNANCE_LOCK_PATH));
     await writeGovernanceLock(projectRoot, result.lockEntries);
     result.materialized.push({
       path: GOVERNANCE_LOCK_PATH,
@@ -1840,54 +1976,54 @@ async function materializeHooks(options) {
   return result;
 }
 async function unmaterializeHooks(projectRoot, lockEntries) {
-  const root = resolve3(projectRoot);
+  const root = resolve4(projectRoot);
   for (const entry of lockEntries) {
     if (entry.type === "generated") {
-      const absPath = join3(root, entry.path);
-      if (existsSync2(absPath)) {
-        await writeFile2(absPath, "", "utf8");
+      const absPath = join4(root, entry.path);
+      if (existsSync3(absPath)) {
+        await writeFile3(absPath, "", "utf8");
       }
       continue;
     }
     if (entry.type === "git-hook") {
-      const absPath = join3(root, entry.path);
+      const absPath = join4(root, entry.path);
       const existing = await readTextFileIfExists(absPath);
       if (existing === void 0) continue;
       const updated = removeManagedBlock(existing);
-      await writeFile2(absPath, updated, "utf8");
+      await writeFile3(absPath, updated, "utf8");
       continue;
     }
     if (entry.type === "cursor-hook") {
-      const absPath = join3(root, entry.path);
+      const absPath = join4(root, entry.path);
       const existingRaw = await readTextFileIfExists(absPath);
       if (existingRaw === void 0) continue;
       const existing = parseCursorHooksFile(existingRaw);
       const commandsToRemove = buildDefaultCursorHooks(DEFAULT_RECORDER).map((h) => h.command);
       const updated = removeCursorHooks(existing, commandsToRemove);
-      await writeFile2(absPath, serializeCursorHooksFile(updated), "utf8");
+      await writeFile3(absPath, serializeCursorHooksFile(updated), "utf8");
     }
   }
-  const lockPath = join3(root, GOVERNANCE_LOCK_PATH);
-  if (existsSync2(lockPath)) {
-    await writeFile2(lockPath, "", "utf8");
+  const lockPath = join4(root, GOVERNANCE_LOCK_PATH);
+  if (existsSync3(lockPath)) {
+    await writeFile3(lockPath, "", "utf8");
   }
 }
 async function copyCLIBinary(srcPath, projectRoot, destRelPath = DEFAULT_BINARY_DEST) {
-  const dstPath = join3(projectRoot, destRelPath);
-  const srcContent = await readFile2(srcPath);
+  const dstPath = join4(projectRoot, destRelPath);
+  const srcContent = await readFile3(srcPath);
   const srcHash = createHash("sha256").update(srcContent).digest("hex");
-  if (existsSync2(dstPath)) {
-    const dstContent = await readFile2(dstPath);
+  if (existsSync3(dstPath)) {
+    const dstContent = await readFile3(dstPath);
     const dstHash = createHash("sha256").update(dstContent).digest("hex");
     if (srcHash === dstHash) {
       return { path: destRelPath, action: "unchanged" };
     }
-    await writeFile2(dstPath, srcContent);
+    await writeFile3(dstPath, srcContent);
     await chmod(dstPath, 493);
     return { path: destRelPath, action: "updated" };
   }
   await ensureParentDir(dstPath);
-  await writeFile2(dstPath, srcContent);
+  await writeFile3(dstPath, srcContent);
   await chmod(dstPath, 493);
   return { path: destRelPath, action: "created" };
 }
@@ -1897,7 +2033,9 @@ var SCAFFOLD_PROJECT_YAML = `schema: aaac/project/0.1
 #
 # environments:
 #   git:
-#     hooks: [pre-commit, pre-push, post-commit]
+#     # commit-msg/post-commit are observability-only (promotion axis): post-commit
+#     # records promotion.commit + promotion.file, feeding Enricher R1/R2/R5.
+#     hooks: [pre-commit, commit-msg, post-commit, pre-push]
 #   cursor:
 #     hooks_json: .cursor/hooks.json
 #
@@ -1954,4 +2092,4 @@ export {
   copyCLIBinary,
   SCAFFOLD_PROJECT_YAML
 };
-//# sourceMappingURL=chunk-JWJLY3HJ.js.map
+//# sourceMappingURL=chunk-F57V745S.js.map