@kylecheng3146/agent-ops 0.1.4 → 0.1.6

package/dist/runtime/src/adapters/opencode/config.js

@@ -0,0 +1,170 @@
+import { homedir } from "node:os";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { AgentOpsError } from "../../fs/paths.js";
+export const OPENCODE_MANAGED_MARKER = "--managed-by=agent-ops";
+export const OPENCODE_PLUGIN_PATH = ".opencode/plugins/agent-ops.js";
+export const OPENCODE_USER_PLUGIN_PATH = ".config/opencode/plugins/agent-ops.js";
+function userPluginPath(root, configuredHome = process.env.XDG_CONFIG_HOME, configuredDirectory = process.env.OPENCODE_CONFIG_DIR) {
+    const installationRoot = resolve(root ?? process.env.AGENT_OPS_HOME ?? homedir());
+    const customConfigDirectory = configuredDirectory?.trim();
+    const configDirectory = customConfigDirectory !== undefined && customConfigDirectory.length > 0
+        ? customConfigDirectory
+        : configuredHome === undefined || configuredHome.trim().length === 0
+            ? join(installationRoot, ".config", "opencode")
+            : join(configuredHome, "opencode");
+    if (!isAbsolute(configDirectory)) {
+        throw new AgentOpsError("OPENCODE_CONFIG_PATH_INVALID", "OpenCode's config directory must be an absolute path for user-scope installation.");
+    }
+    const target = resolve(configDirectory, "plugins", "agent-ops.js");
+    const relativeTarget = relative(installationRoot, target);
+    if (relativeTarget.length === 0 ||
+        relativeTarget === ".." ||
+        relativeTarget.startsWith(`..${sep}`) ||
+        isAbsolute(relativeTarget)) {
+        throw new AgentOpsError("OPENCODE_CONFIG_PATH_INVALID", "OpenCode's config directory must stay inside the managed user-scope root.");
+    }
+    return relativeTarget.split(sep).join("/");
+}
+export function opencodePluginTarget(scope, root, configuredHome, configuredDirectory) {
+    return {
+        path: scope === "project"
+            ? OPENCODE_PLUGIN_PATH
+            : root === undefined && configuredHome === undefined &&
+                configuredDirectory === undefined &&
+                process.env.XDG_CONFIG_HOME === undefined &&
+                process.env.OPENCODE_CONFIG_DIR === undefined
+                ? OPENCODE_USER_PLUGIN_PATH
+                : userPluginPath(root, configuredHome, configuredDirectory),
+        representation: "javascript",
+        requiresProjectTrust: scope === "project"
+    };
+}
+/**
+ * Validates the persisted plugin shape without consulting the current
+ * environment. User-scope installations may use a custom config directory,
+ * so their manifest path is allowed to have any safe prefix but must still
+ * name OpenCode's plugin entrypoint.
+ */
+export function isOpencodePluginPath(scope, path) {
+    if (scope === "project") {
+        return path === OPENCODE_PLUGIN_PATH;
+    }
+    return /^(?:[A-Za-z0-9._-]+\/)*plugins\/agent-ops\.js$/u.test(path);
+}
+function isAbsoluteRuntimePath(value) {
+    return (value.startsWith("/") ||
+        /^[A-Za-z]:[\\/]/u.test(value) ||
+        value.startsWith("\\\\"));
+}
+function assertRuntimePath(runtimePath) {
+    if (!isAbsoluteRuntimePath(runtimePath) ||
+        runtimePath.length > 4096 ||
+        runtimePath.includes("\0") ||
+        runtimePath.includes("\n") ||
+        runtimePath.includes("\r")) {
+        throw new AgentOpsError("OPENCODE_PLUGIN_PATH_INVALID", "opencode plugin runtime path must be absolute and valid.");
+    }
+}
+export function opencodePluginEvents(capabilities) {
+    const events = [];
+    if (capabilities.includes("lifecycle-summary")) {
+        events.push("SessionStart");
+    }
+    if (capabilities.includes("command-policy")) {
+        events.push("PreToolUse");
+    }
+    if (capabilities.includes("optional-stop-verify")) {
+        events.push("Stop");
+    }
+    return events;
+}
+/**
+ * Generates the dependency-free plugin installed under the selected local
+ * or user plugin directory.
+ * The only host dependency is opencode's Bun `$` shell tag, supplied by the
+ * plugin context. Keeping the shell function in the context makes the source
+ * importable under Node tests with a small fake.
+ */
+export function buildOpencodePlugin(capabilities, runtimePath) {
+    const events = opencodePluginEvents(capabilities);
+    if (events.length === 0) {
+        return null;
+    }
+    assertRuntimePath(runtimePath);
+    const lines = [
+        "// Managed by agent-ops. Do not edit: `agent-ops update` rewrites this file.",
+        `const RUNTIME_PATH = ${JSON.stringify(runtimePath)};`,
+        `const MARKER = ${JSON.stringify(OPENCODE_MANAGED_MARKER)};`,
+        "",
+        "function outputText(result) {",
+        "  if (typeof result?.stdout === \"string\") return result.stdout;",
+        "  return new TextDecoder().decode(result?.stdout ?? new Uint8Array());",
+        "}",
+        "",
+        "async function invokeRuntime($, event, payload, projectRoot) {",
+        "  try {",
+        "    const result = await $`node ${RUNTIME_PATH} opencode ${event} ${MARKER} < ${new Response(JSON.stringify(payload))}`.cwd(projectRoot).quiet();",
+        "    const decision = JSON.parse(outputText(result).trim());",
+        "    if (decision?.decision !== \"allow\" && decision?.decision !== \"deny\") return null;",
+        "    return decision;",
+        "  } catch {",
+        "    return null;",
+        "  }",
+        "}",
+        "",
+        "async function runManagedHook($, event, payload) {",
+        "  const decision = await invokeRuntime($, event, payload, payload.projectRoot);",
+        "  if (decision === null) {",
+        "    if (event === \"PreToolUse\") throw new Error(\"agent-ops: command policy is unavailable\");",
+        "    return;",
+        "  }",
+        "  if (decision.decision === \"deny\") {",
+        "    throw new Error(`agent-ops: ${decision.reason ?? \"denied\"}`);",
+        "  }",
+        "}",
+        "",
+        "export const AgentOps = async ({ $, directory, worktree } = {}) => {",
+        "  const projectRoot = directory ?? worktree ?? process.cwd();",
+        "  const hooks = {};"
+    ];
+    if (events.includes("SessionStart")) {
+        lines.push("  // opencode initializes plugins once per app, not once per session.", "  await runManagedHook($, \"SessionStart\", {", "    event: \"SessionStart\",", "    projectRoot", "  });");
+    }
+    if (events.includes("PreToolUse")) {
+        lines.push('  hooks["tool.execute.before"] = async (input, output) => {', '    if (input?.tool !== "bash") return;', "    await runManagedHook($, \"PreToolUse\", {", "      event: \"PreToolUse\",", "      projectRoot,", "      input,", "      output", "    });", "  };");
+    }
+    if (events.includes("Stop")) {
+        lines.push("  hooks.event = async ({ event }) => {", '    if (event?.type !== "session.idle") return;', "    await runManagedHook($, \"Stop\", { event: \"Stop\", projectRoot });", "  };");
+    }
+    lines.push("  return hooks;", "};", "");
+    return lines.join("\n");
+}
+export function isOpencodeManagedPlugin(source) {
+    return (source !== null &&
+        source.includes("Managed by agent-ops") &&
+        source.includes(OPENCODE_MANAGED_MARKER));
+}
+/**
+ * Registration probing checks the generated source's managed marker and the
+ * capability-implied hook registrations. The artifact hash check remains the
+ * exact-content check; this probe answers whether the relevant hooks exist.
+ */
+export function isOpencodePluginRegistered(source, capabilities) {
+    if (typeof source !== "string") {
+        return opencodePluginEvents(capabilities).length === 0;
+    }
+    if (!isOpencodeManagedPlugin(source)) {
+        return false;
+    }
+    return opencodePluginEvents(capabilities).every((event) => {
+        if (event === "SessionStart") {
+            return source.includes('runManagedHook($, "SessionStart"');
+        }
+        if (event === "PreToolUse") {
+            return source.includes('"tool.execute.before"') &&
+                source.includes('runManagedHook($, "PreToolUse"');
+        }
+        return source.includes('event?.type !== "session.idle"') &&
+            source.includes('runManagedHook($, "Stop"');
+    });
+}

package/dist/runtime/src/adapters/opencode/events.js

@@ -0,0 +1,49 @@
+export const OPENCODE_SUPPORTED_EVENTS = [
+    "SessionStart",
+    "PreToolUse",
+    "Stop"
+];
+/**
+ * opencode exposes plugin hooks rather than named lifecycle events. Only
+ * `tool.execute.before` is documented as able to stop an action, so blocking
+ * outcomes for the other two stay UNKNOWN the way the Codex adapter records
+ * unconfirmed native behavior.
+ */
+export const OPENCODE_PLUGIN_HOOKS = {
+    SessionStart: "plugin-init",
+    PreToolUse: "tool.execute.before",
+    Stop: "event:session.idle"
+};
+export const OPENCODE_PRE_TOOL_BLOCKING = "throws";
+export const OPENCODE_STOP_BLOCKING = "UNKNOWN";
+/**
+ * A plugin's factory runs once when opencode starts, not once per session, so
+ * SessionStart is a degraded approximation rather than an equivalent.
+ */
+export const OPENCODE_SESSION_START_FIDELITY = "app-init";
+export const OPENCODE_CAPABILITY_REGISTRATIONS = [
+    {
+        capability: "lifecycle-summary",
+        normalizedEvent: "session-start",
+        nativeEvent: "SessionStart",
+        surfaceId: "opencode-plugin",
+        support: "degraded",
+        runtimeFailure: "fail-open"
+    },
+    {
+        capability: "command-policy",
+        normalizedEvent: "command",
+        nativeEvent: "PreToolUse",
+        surfaceId: "opencode-plugin",
+        support: "supported",
+        runtimeFailure: "fail-closed"
+    },
+    {
+        capability: "optional-stop-verify",
+        normalizedEvent: "stop",
+        nativeEvent: "Stop",
+        surfaceId: "opencode-plugin",
+        support: "degraded",
+        runtimeFailure: "fail-open"
+    }
+];

package/dist/runtime/src/adapters/opencode/input.js

@@ -0,0 +1,32 @@
+import { normalizeHookEvent } from "../../hooks/normalize.js";
+import { normalizeShellHookEvent } from "../../hooks/shell.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * The managed plugin forwards opencode's own hook payload untouched under
+ * `input`, so every field this adapter reads is documented plugin input rather
+ * than a shape the plugin invented.
+ */
+export function normalizeOpencodeHookInput(input) {
+    if (!isRecord(input)) {
+        return normalizeHookEvent(input);
+    }
+    const projectRoot = input.projectRoot;
+    if (input.event === "SessionStart") {
+        return normalizeHookEvent({ event: "session-start", projectRoot });
+    }
+    if (input.event === "Stop") {
+        return normalizeHookEvent({ event: "stop", projectRoot });
+    }
+    if (input.event === "PreToolUse" &&
+        isRecord(input.input) &&
+        input.input.tool === "bash" &&
+        isRecord(input.output) &&
+        isRecord(input.output.args) &&
+        typeof input.output.args.command === "string" &&
+        typeof projectRoot === "string") {
+        return normalizeShellHookEvent(input.output.args.command, projectRoot);
+    }
+    return normalizeHookEvent({ event: "unsupported", projectRoot });
+}

package/dist/runtime/src/adapters/opencode/output.js

@@ -0,0 +1,23 @@
+/**
+ * The consumer is the managed plugin, so the wire format is ours to define: one
+ * JSON decision on stdout. Only `tool.execute.before` can act on a denial, so
+ * the other events always report `allow` and carry the code for logging.
+ */
+export function opencodeHookOutput(event, result) {
+    const decision = event === "PreToolUse" && result.action === "block"
+        ? { decision: "deny", reason: result.code }
+        : {
+            decision: "allow",
+            ...(result.status === "PASS" && event !== "Stop"
+                ? {}
+                : { reason: result.code }),
+            ...(event === "Stop" && result.evidence !== undefined
+                ? { evidence: result.evidence }
+                : {})
+        };
+    return {
+        exitCode: 0,
+        stdout: JSON.stringify(decision),
+        stderr: ""
+    };
+}

package/dist/runtime/src/adapters/opencode/surfaces.js

@@ -0,0 +1,23 @@
+import { opencodePluginTarget } from "./config.js";
+export const OPENCODE_SURFACE_IDS = {
+    plugin: "opencode-plugin",
+    config: "opencode-config"
+};
+export function opencodeSurfaces(scope, root) {
+    return [
+        {
+            id: OPENCODE_SURFACE_IDS.plugin,
+            path: opencodePluginTarget(scope, root).path,
+            scope,
+            access: "managed-default",
+            representation: "javascript"
+        },
+        {
+            id: OPENCODE_SURFACE_IDS.config,
+            path: "opencode.json",
+            scope,
+            access: "inspect-only",
+            representation: "json"
+        }
+    ];
+}

package/dist/runtime/src/config/explain.js

@@ -1,6 +1,13 @@
 export function explainConfig(merged) {
     return {
         schemaVersion: merged.config.schemaVersion,
+        features: {
+            stopVerification: {
+                enabled: merged.config.features.stopVerification.enabled,
+                source: merged.provenance.features.source,
+                sourcePath: merged.provenance.features.sourcePath
+            }
+        },
         profiles: merged.provenance.profiles.map((entry) => ({
             id: entry.value,
             source: entry.source,

package/dist/runtime/src/config/hash.js

@@ -0,0 +1,24 @@
+import { sha256 } from "../fs/hash.js";
+import { AgentOpsError } from "../fs/paths.js";
+function canonicalJson(value) {
+    if (value === null ||
+        typeof value === "boolean" ||
+        typeof value === "number" ||
+        typeof value === "string") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(canonicalJson).join(",")}]`;
+    }
+    if (typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`)
+            .join(",")}}`;
+    }
+    throw new AgentOpsError("CONFIG_HASH_INVALID", "Configuration contains an unsupported value.");
+}
+export function calculateConfigHash(config) {
+    return sha256(canonicalJson(config));
+}

package/dist/runtime/src/config/merge.js

@@ -108,8 +108,10 @@ export function mergeConfigLayers(inputLayers) {
     const mappings = new Map();
     const exceptions = new Map();
     let schemaVersion;
+    let features;
     for (const layer of layers) {
         schemaVersion = effective(layer.config.schemaVersion, layer);
+        features = effective(layer.config.features, layer);
         for (const profile of layer.config.profiles) {
             profiles.set(profile, effective(profile, layer));
         }
@@ -139,22 +141,24 @@ export function mergeConfigLayers(inputLayers) {
             exceptions.set(key, effective(securityException, layer));
         }
     }
-    if (schemaVersion === undefined) {
+    if (schemaVersion === undefined || features === undefined) {
         throw new AgentOpsError("CONFIG_LAYER_REQUIRED", "At least one configuration layer is required.");
     }
     const provenance = {
         schemaVersion,
+        features,
         profiles: [...profiles.values()],
         verificationCommands: [...commands.values()],
         pathMappings: [...mappings.values()],
         securityExceptions: [...exceptions.values()]
     };
     const config = {
-        schemaVersion: 1,
+        schemaVersion: schemaVersion.value,
         profiles: provenance.profiles.map(({ value }) => value),
         verification: {
             commands: provenance.verificationCommands.map(({ value }) => value)
         },
+        features: provenance.features.value,
         pathMappings: provenance.pathMappings.map(({ value }) => value),
         securityExceptions: provenance.securityExceptions.map(({ value }) => value)
     };

package/dist/runtime/src/config/migrate.js

@@ -1,4 +1,4 @@
-import { SCHEMA_VERSION } from "../contracts.js";
+import { CONFIG_SCHEMA_VERSION } from "../contracts.js";
 import { AgentOpsError } from "../fs/paths.js";
 import { validateConfig } from "../schema/validate.js";
 function isRecord(value) {
@@ -18,6 +18,21 @@ const MIGRATIONS = new Map([
                 verification: { commands: clone(commands) }
             };
         }
+    ],
+    [
+        1,
+        (input) => {
+            const { schemaVersion: _schemaVersion, ...rest } = input;
+            return {
+                ...rest,
+                schemaVersion: CONFIG_SCHEMA_VERSION,
+                features: {
+                    stopVerification: {
+                        enabled: false
+                    }
+                }
+            };
+        }
     ]
 ]);
 function schemaVersionOf(value) {
@@ -30,13 +45,13 @@ function schemaVersionOf(value) {
 }
 export function previewConfigMigration(input) {
     const sourceVersion = schemaVersionOf(input);
-    if (sourceVersion > SCHEMA_VERSION) {
-        throw new AgentOpsError("CONFIG_SCHEMA_FUTURE", `Config schemaVersion ${sourceVersion} is newer than supported version ${SCHEMA_VERSION}.`);
+    if (sourceVersion > CONFIG_SCHEMA_VERSION) {
+        throw new AgentOpsError("CONFIG_SCHEMA_FUTURE", `Config schemaVersion ${sourceVersion} is newer than supported version ${CONFIG_SCHEMA_VERSION}.`);
     }
     let migrated = clone(input);
     let version = sourceVersion;
     const steps = [];
-    while (version < SCHEMA_VERSION) {
+    while (version < CONFIG_SCHEMA_VERSION) {
         const migration = MIGRATIONS.get(version);
         if (migration === undefined || !isRecord(migrated)) {
             throw new AgentOpsError("CONFIG_MIGRATION_MISSING", `No migration is registered from config schemaVersion ${version}.`);

package/dist/runtime/src/contracts.js

@@ -1 +1,10 @@
-export const SCHEMA_VERSION = 1;
+export const CONFIG_SCHEMA_VERSION = 2;
+export const TASK_SCHEMA_VERSION = 1;
+export const EVIDENCE_SCHEMA_VERSION = 1;
+/** @deprecated Use the document-specific schema version constants. */
+export const SCHEMA_VERSION = CONFIG_SCHEMA_VERSION;
+/**
+ * The manifest versions independently of config, tasks, and evidence: only its
+ * own shape changed when the harness selection became a list.
+ */
+export const MANIFEST_SCHEMA_VERSION = 2;

package/dist/runtime/src/fs/managed-block.js

@@ -7,37 +7,54 @@ function assertBlockId(id) {
         throw new AgentOpsError("INVALID_BLOCK_ID", `Invalid block ID: ${id}`);
     }
 }
-function assertExactMarkerSyntax(source) {
-    const validMarker = /^<!-- agent-ops:(?:start [a-z][a-z0-9-]{0,127} v[1-9][0-9]*|end [a-z][a-z0-9-]{0,127}) -->$/;
+function assertExactMarkerSyntax(source, markerStyle) {
+    const validMarker = markerStyle === "html"
+        ? /^<!-- agent-ops:(?:start [a-z][a-z0-9-]{0,127} v[1-9][0-9]*|end [a-z][a-z0-9-]{0,127}) -->$/
+        : /^# agent-ops:(?:start [a-z][a-z0-9-]{0,127} v[1-9][0-9]*|end [a-z][a-z0-9-]{0,127})$/;
+    const markerPrefix = markerStyle === "html"
+        ? /<!--\s*agent-ops:/
+        : /#\s*agent-ops:/;
     for (const line of source.split(/\r?\n/)) {
-        if (/<!--\s*agent-ops:/.test(line) && !validMarker.test(line)) {
+        if (markerPrefix.test(line) && !validMarker.test(line)) {
             throw new AgentOpsError("MALFORMED_MANAGED_BLOCK", "Managed block markers must use the exact agent-ops marker syntax.");
         }
     }
 }
-export function managedBlockMarkers(id, version) {
+export function managedBlockMarkers(id, version, markerStyle = "html") {
     assertBlockId(id);
     if (!Number.isSafeInteger(version) || version < 1) {
         throw new AgentOpsError("INVALID_BLOCK_VERSION", `Invalid block version: ${version}`);
     }
-    return {
-        start: `<!-- agent-ops:start ${id} v${version} -->`,
-        end: `<!-- agent-ops:end ${id} -->`
-    };
+    return markerStyle === "html"
+        ? {
+            start: `<!-- agent-ops:start ${id} v${version} -->`,
+            end: `<!-- agent-ops:end ${id} -->`
+        }
+        : {
+            start: `# agent-ops:start ${id} v${version}`,
+            end: `# agent-ops:end ${id}`
+        };
 }
-function locateMarkers(source, id, version) {
+function locateMarkers(source, id, version, markerStyle = "html") {
     assertBlockId(id);
-    assertExactMarkerSyntax(source);
+    assertExactMarkerSyntax(source, markerStyle);
     const escapedId = escapeRegExp(id);
+    const startPattern = markerStyle === "html"
+        ? `<!-- agent-ops:start ${escapedId} v[0-9]+ -->`
+        : `# agent-ops:start ${escapedId} v[0-9]+`;
+    const end = markerStyle === "html"
+        ? `<!-- agent-ops:end ${id} -->`
+        : `# agent-ops:end ${id}`;
     const startMatches = [
-        ...source.matchAll(new RegExp(`<!-- agent-ops:start ${escapedId} v[0-9]+ -->`, "g"))
+        ...source.matchAll(new RegExp(startPattern, "g"))
     ];
-    const end = `<!-- agent-ops:end ${id} -->`;
     const endMatches = [...source.matchAll(new RegExp(escapeRegExp(end), "g"))];
     if (startMatches.length === 0 && endMatches.length === 0) {
         return null;
     }
-    const expectedStart = version === undefined ? startMatches[0]?.[0] : managedBlockMarkers(id, version).start;
+    const expectedStart = version === undefined
+        ? startMatches[0]?.[0]
+        : managedBlockMarkers(id, version, markerStyle).start;
     const start = startMatches[0]?.[0];
     const startIndex = startMatches[0]?.index;
     const endIndex = endMatches[0]?.index;
@@ -54,16 +71,16 @@ function locateMarkers(source, id, version) {
     return { start, end, startIndex, endIndex };
 }
 function renderBlock(options) {
-    if (/<!--\s*agent-ops:/.test(options.content)) {
+    if (/(?:<!--|#)\s*agent-ops:/.test(options.content)) {
         throw new AgentOpsError("AMBIGUOUS_MANAGED_CONTENT", "Managed content must not contain agent-ops marker boundaries.");
     }
-    const { start, end } = managedBlockMarkers(options.id, options.version);
+    const { start, end } = managedBlockMarkers(options.id, options.version, options.markerStyle);
     const content = options.content.replace(/\r\n/g, "\n").replace(/\n+$/g, "");
     return `${start}\n${content}\n${end}`;
 }
 export function applyManagedBlock(source, options) {
     const block = renderBlock(options);
-    const located = locateMarkers(source, options.id, options.version);
+    const located = locateMarkers(source, options.id, options.version, options.markerStyle);
     if (located === null) {
         if (source.length === 0) {
             return `${block}\n`;
@@ -72,8 +89,8 @@ export function applyManagedBlock(source, options) {
     }
     return `${source.slice(0, located.startIndex)}${block}${source.slice(located.endIndex + located.end.length)}`;
 }
-export function removeManagedBlock(source, id) {
-    const located = locateMarkers(source, id);
+export function removeManagedBlock(source, id, markerStyle = "html") {
+    const located = locateMarkers(source, id, undefined, markerStyle);
     if (located === null) {
         return source;
     }

package/dist/runtime/src/fs/manifest.js

@@ -1,6 +1,37 @@
+import { MANIFEST_SCHEMA_VERSION } from "../contracts.js";
 import { validateManifest } from "../schema/validate.js";
 import { AgentOpsError } from "./paths.js";
 export const PROJECT_MANIFEST_PATH = ".agent-ops/manifest.json";
+const LEGACY_HARNESS_SELECTIONS = {
+    both: ["codex", "claude"],
+    claude: ["claude"],
+    codex: ["codex"]
+};
+/**
+ * Manifests written up to 0.1.4 stored a single harness string, with `"both"`
+ * standing in for two harnesses. Reading one upgrades it in memory; the file is
+ * rewritten the next time `update` runs.
+ */
+function migrateLegacyManifest(value) {
+    if (typeof value !== "object" ||
+        value === null ||
+        Array.isArray(value)) {
+        return value;
+    }
+    const record = value;
+    if (record.schemaVersion !== 1 || typeof record.harness !== "string") {
+        return value;
+    }
+    const harness = LEGACY_HARNESS_SELECTIONS[record.harness];
+    if (harness === undefined) {
+        return value;
+    }
+    return {
+        ...record,
+        schemaVersion: MANIFEST_SCHEMA_VERSION,
+        harness
+    };
+}
 export function parseInstallManifest(source) {
     let value;
     try {
@@ -9,7 +40,7 @@ export function parseInstallManifest(source) {
     catch (error) {
         throw new AgentOpsError("MANIFEST_INVALID_JSON", "The installation manifest is not valid JSON.", { cause: error });
     }
-    const result = validateManifest(value);
+    const result = validateManifest(migrateLegacyManifest(value));
     if (!result.ok) {
         throw new AgentOpsError("MANIFEST_INVALID", `${result.errors[0]?.path ?? "$"}: ${result.errors[0]?.message ?? "Invalid installation manifest."}`);
     }

package/dist/runtime/src/fs/transaction.js

@@ -147,13 +147,25 @@ function assertTransactionPlan(plan) {
         }
         if (operation.kind === "write") {
             if (typeof operation.content !== "string" ||
-                !hasOnlyKeys(operation, ["kind", "path", "content", "expectedHash"])) {
+                (operation.disclosure !== undefined &&
+                    operation.disclosure !== "full" &&
+                    operation.disclosure !== "opaque") ||
+                !hasOnlyKeys(operation, [
+                    "kind",
+                    "path",
+                    "content",
+                    "expectedHash",
+                    "disclosure"
+                ])) {
                 throw new AgentOpsError("INVALID_TRANSACTION_PLAN", `Invalid write operation at index ${index}.`);
             }
             continue;
         }
         if (operation.kind !== "remove" ||
-            !hasOnlyKeys(operation, ["kind", "path", "expectedHash"])) {
+            (operation.disclosure !== undefined &&
+                operation.disclosure !== "full" &&
+                operation.disclosure !== "opaque") ||
+            !hasOnlyKeys(operation, ["kind", "path", "expectedHash", "disclosure"])) {
             throw new AgentOpsError("INVALID_TRANSACTION_PLAN", `Invalid remove operation at index ${index}.`);
         }
     }

package/dist/runtime/src/hooks/advisory.js

@@ -0,0 +1,16 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { appendLocalLog } from "../logging/local-log.js";
+import { localStatePaths } from "../security/permissions.js";
+/**
+ * Records the bounded lifecycle summary signal locally. It deliberately does
+ * not include project paths, prompts, commands, or verification evidence.
+ */
+export async function runLifecycleAdvisory(_event, options = {}) {
+    const home = options.homeDirectory ?? process.env.AGENT_OPS_HOME ?? homedir();
+    const state = localStatePaths(home);
+    await appendLocalLog(join(state.logDirectory, "events.ndjson"), { type: "diagnostic", code: "LIFECYCLE_SUMMARY" }, {
+        anchorDirectory: state.anchorDirectory,
+        ...(options.now === undefined ? {} : { now: options.now })
+    });
+}