@open-agent-toolkit/cli 0.3.7 → 0.3.9

package/dist/commands/project/dispatch/canonical-role.js

@@ -0,0 +1,114 @@
+import { isAbsolute, join, resolve } from 'node:path';
+import { resolveCanonicalRole, } from '../../../agents/canonical/index.js';
+import { readGlobalOptions } from '../../shared/shared.utils.js';
+import { dirExists, fileExists } from '../../../fs/io.js';
+import { safeParseOatDispatchEvidenceEvent } from '../../../providers/identity/oat-dispatch-record.js';
+import { Command } from 'commander';
+import { redactDispatchMessage } from './record.js';
+/** The pack that ships the canonical OAT dispatch roles. */
+export const CANONICAL_ROLE_DEPENDENCY = 'workflows';
+const REQUEST_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/;
+const ROLE_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]*$/;
+async function loadedSkillDir(cwd, skillDir) {
+    const candidate = isAbsolute(skillDir) ? skillDir : resolve(cwd, skillDir);
+    if (!(await dirExists(candidate)) ||
+        !(await fileExists(join(candidate, 'SKILL.md')))) {
+        throw new Error(`--skill-dir must name a loaded skill directory containing SKILL.md (got ${skillDir}); the loaded tier is derived from it.`);
+    }
+    return candidate;
+}
+/**
+ * Produce `canonical-role-resolution` evidence from the resolver itself, so a
+ * caller never hand-assembles redacted paths or a content digest. Read-only:
+ * it inspects the loaded, user, and project `.agents` roots and writes
+ * nothing. The emitted event is checked against the recorder's own event
+ * schema before it is printed, so `oat project dispatch record` accepts it
+ * unchanged.
+ */
+export async function produceCanonicalRoleEvent(input) {
+    if (!ROLE_NAME_PATTERN.test(input.role)) {
+        throw new Error('--role must be a canonical role name: expected [a-z0-9] followed by [a-z0-9_-].');
+    }
+    if (!REQUEST_ID_PATTERN.test(input.requestId)) {
+        throw new Error('--request-id must be a stable contained identifier: expected [a-zA-Z0-9] followed by up to 127 of [a-zA-Z0-9._-].');
+    }
+    const skillDir = await loadedSkillDir(input.cwd, input.skillDir);
+    const event = {
+        kind: 'canonical-role-resolution',
+        requestId: input.requestId,
+        source: 'canonical-role-resolver',
+        evidence: resolveCanonicalRole({
+            dependency: CANONICAL_ROLE_DEPENDENCY,
+            canonicalRole: input.role,
+            skillDir,
+            userCanonicalRoot: join(input.home, '.agents'),
+            projectCanonicalRoot: join(input.repoRoot, '.agents'),
+        }),
+    };
+    const checked = safeParseOatDispatchEvidenceEvent(event);
+    if (!checked.success) {
+        throw new Error(`Canonical role evidence failed the dispatch-record event schema: ${checked.error.issues
+            .map((issue) => `${issue.path.join('.') || '<root>'}: ${issue.message}`)
+            .join('; ')}`);
+    }
+    return event;
+}
+function summaryLines(event) {
+    const { evidence } = event;
+    if (evidence.status === 'resolved') {
+        return [
+            `Canonical role ${evidence.canonicalRole} resolved from the ${evidence.tier} tier (${evidence.validation}, version ${evidence.roleVersion}).`,
+        ];
+    }
+    return [
+        `Canonical role ${evidence.canonicalRole} was not found in the loaded, user, or project tier.`,
+        ...evidence.recovery.map(({ command }) => `Recovery: ${command}`),
+    ];
+}
+async function runCanonicalRoleCommand(options, context, dependencies) {
+    let repoRoot = null;
+    try {
+        repoRoot = await dependencies.resolveProjectRoot(context.cwd);
+        const event = await produceCanonicalRoleEvent({
+            role: options.role,
+            requestId: options.requestId,
+            skillDir: options.skillDir,
+            cwd: context.cwd,
+            home: context.home,
+            repoRoot,
+        });
+        if (context.json) {
+            context.logger.json(event);
+        }
+        else {
+            for (const line of summaryLines(event)) {
+                context.logger.info(line);
+            }
+            context.logger.info(JSON.stringify(event, null, 2));
+        }
+        process.exitCode = 0;
+    }
+    catch (error) {
+        // The same single redaction boundary as `dispatch record`: a skill
+        // directory or root that reaches a message is labelled or scrubbed.
+        const message = redactDispatchMessage(error instanceof Error ? error.message : String(error), { repo: repoRoot, home: context.home });
+        if (context.json) {
+            context.logger.json({ status: 'error', message });
+        }
+        else {
+            context.logger.error(message);
+        }
+        process.exitCode = 1;
+    }
+}
+export function createCanonicalRoleCommand(dependencies) {
+    return new Command('canonical-role')
+        .description('Print canonical-role-resolution evidence for a dispatch record (read-only)')
+        .requiredOption('--role <name>', 'Canonical role name, e.g. oat-reviewer')
+        .requiredOption('--request-id <id>', 'Request ID of the dispatch record the evidence belongs to')
+        .requiredOption('--skill-dir <dir>', 'Directory of the loaded skill (contains SKILL.md); the loaded tier is derived from it')
+        .action(async (options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        await runCanonicalRoleCommand(options, context, dependencies);
+    });
+}

package/dist/commands/project/dispatch/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/dispatch/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC,MAAM,WAAW,kCAAkC;IACjD,mBAAmB,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,cAAc,CAAC;IAChE,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5C,SAAS,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;CAClC;AA0ID,wBAAgB,4BAA4B,CAC1C,SAAS,GAAE,OAAO,CAAC,kCAAkC,CAAM,GAC1D,OAAO,CA2BT"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/dispatch/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAcpC,MAAM,WAAW,kCAAkC;IACjD,mBAAmB,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,cAAc,CAAC;IAChE,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5C,SAAS,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;CAClC;AA0ID,wBAAgB,4BAA4B,CAC1C,SAAS,GAAE,OAAO,CAAC,kCAAkC,CAAM,GAC1D,OAAO,CA4BT"}

package/dist/commands/project/dispatch/index.js

@@ -5,6 +5,7 @@ import { readGlobalOptions } from '../../shared/shared.utils.js';
 import { fileExists } from '../../../fs/io.js';
 import { resolveProjectRoot, validateRealPathWithinScope } from '../../../fs/paths.js';
 import { Command } from 'commander';
+import { createCanonicalRoleCommand } from './canonical-role.js';
 import { recordProjectDispatch, redactDispatchMessage, } from './record.js';
 const DEFAULT_DEPENDENCIES = {
     buildCommandContext,
@@ -133,5 +134,6 @@ export function createProjectDispatchCommand(overrides = {}) {
         .action(async (options, command) => {
         const context = dependencies.buildCommandContext(readGlobalOptions(command));
         await runRecordCommand(options, context, dependencies);
-    }));
+    }))
+        .addCommand(createCanonicalRoleCommand(dependencies));
 }

package/dist/commands/project/dispatch/record.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/dispatch/record.ts"],"names":[],"mappings":"AAkBA,OAAO,EAKL,KAAK,qBAAqB,EAC3B,MAAM,6CAA6C,CAAC;AACrD,OAAO,EAOL,KAAK,wBAAwB,EAE7B,KAAK,4BAA4B,EAElC,MAAM,yCAAyC,CAAC;AAWjD;;;;;GAKG;AACH,MAAM,WAAW,0BAA0B;IACzC,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC;AAoCD;;;;;;;;;GASG;AAEH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,KAAK,GAAE;IACL,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACjB,GACL,MAAM,CAcR;AAaD,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,qBAAqB,CAAC;IAC9B,KAAK,EAAE,wBAAwB,CAAC;IAChC,uEAAuE;IACvE,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAED;;;;;GAKG;AACH,MAAM,WAAW,6BAA6B;IAC5C,UAAU,EAAE;QACV,QAAQ,EAAE,MAAM,CAAC;QACjB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;QAC5B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;QACrB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QACtB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;KAC5B,CAAC;IACF,QAAQ,EAAE;QACR,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;QAC5B,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QACpB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;QACrB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QACtB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;KAC5B,GAAG,IAAI,CAAC;IACT,KAAK,EAAE,UAAU,GAAG,aAAa,GAAG,gBAAgB,GAAG,IAAI,CAAC;IAC5D;;;OAGG;IACH,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC;;;;OAIG;IACH,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,EAAE,UAAU,GAAG,cAAc,CAAC;CACrC;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,MAAM,EAAE,WAAW,GAAG,gBAAgB,CAAC;IACvC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,4BAA4B,CAAC;IACrC,eAAe,EAAE,6BAA6B,CAAC;CAChD,CAAC;AAsEF,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,mBAAmB,CA0G5E;AAgKD;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CAAC,KAAK,EAAE;IACjD,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,KAAK,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,0BAA0B,CAAC;CAC3C,GAAG,OAAO,CAAC,2BAA2B,CAAC,CA6HvC"}
+{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/dispatch/record.ts"],"names":[],"mappings":"AAuBA,OAAO,EAOL,KAAK,qBAAqB,EAC3B,MAAM,6CAA6C,CAAC;AACrD,OAAO,EAQL,KAAK,wBAAwB,EAE7B,KAAK,4BAA4B,EAElC,MAAM,yCAAyC,CAAC;AAYjD;;;;;GAKG;AACH,MAAM,WAAW,0BAA0B;IACzC,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC;AAoCD;;;;;;;;;GASG;AAEH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,KAAK,GAAE;IACL,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACjB,GACL,MAAM,CAiBR;AAeD,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,qBAAqB,CAAC;IAC9B,KAAK,EAAE,wBAAwB,CAAC;IAChC,uEAAuE;IACvE,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAED;;;;;GAKG;AACH,MAAM,WAAW,6BAA6B;IAC5C,UAAU,EAAE;QACV,QAAQ,EAAE,MAAM,CAAC;QACjB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;QAC5B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;QACrB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QACtB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;KAC5B,CAAC;IACF,QAAQ,EAAE;QACR,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;QAC5B,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QACpB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;QACrB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QACtB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;KAC5B,GAAG,IAAI,CAAC;IACT,KAAK,EAAE,UAAU,GAAG,aAAa,GAAG,gBAAgB,GAAG,IAAI,CAAC;IAC5D;;;OAGG;IACH,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC;;;;OAIG;IACH,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,EAAE,UAAU,GAAG,cAAc,CAAC;CACrC;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,MAAM,EAAE,WAAW,GAAG,gBAAgB,CAAC;IACvC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,4BAA4B,CAAC;IACrC,eAAe,EAAE,6BAA6B,CAAC;CAChD,CAAC;AA8NF,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,mBAAmB,CA6G5E;AAgKD;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CAAC,KAAK,EAAE;IACjD,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,KAAK,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,0BAA0B,CAAC;CAC3C,GAAG,OAAO,CAAC,2BAA2B,CAAC,CA6HvC"}

package/dist/commands/project/dispatch/record.js

@@ -1,13 +1,14 @@
 import { readFile, readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { publishContainedJsonRevision, redactedFsError, withContainedWriterLock, } from '../../../fs/io.js';
-import { acceptClaudeLaunchEnvelope, buildClaudeDispatchRecord, } from '../../../providers/claude/dispatch-envelope.js';
+import { acceptClaudeLaunchEnvelope, buildClaudeDispatchRecord, collectClaudeLaunchViolations, collectClaudeRecordBaseViolations, ManagedClaudeDispatchValidationError, zodIssueViolations, } from '../../../providers/claude/dispatch-envelope.js';
 import { assertJournalIdentityHasNoAbsolutePath, redactAbsolutePaths, } from '../../../providers/identity/absolute-paths.js';
 import { CLAUDE_OBSERVATION_SOURCE } from '../../../providers/identity/claude-runtime-observation.js';
 import { CODEX_OBSERVATION_SOURCE } from '../../../providers/identity/codex-runtime-observation.js';
-import { assertBoundedDispatchRecordSize, assertNoSensitiveDispatchContent, identityFieldsOf, parseGenericDispatchRecord, } from '../../../providers/identity/generic-dispatch-record.js';
-import { augmentDispatchRecord, compareObservedRuntimeMetadata, comparedObservationAxes, configuredInvocationForObservation, parsePersistedOatDispatchRecord, parseRuntimeObservation, } from '../../../providers/identity/oat-dispatch-record.js';
+import { assertBoundedDispatchRecordSize, assertNoSensitiveDispatchContent, collectSensitiveDispatchContent, identityFieldsOf, parseGenericDispatchRecord, redactSensitiveValues, } from '../../../providers/identity/generic-dispatch-record.js';
+import { augmentDispatchRecord, compareObservedRuntimeMetadata, comparedObservationAxes, configuredInvocationForObservation, parsePersistedOatDispatchRecord, parseRuntimeObservation, safeParseOatDispatchEvidenceEvent, } from '../../../providers/identity/oat-dispatch-record.js';
 import { observationFromFacts, parseRuntimeObservationEnvelope, projectRuntimeObservation, providerSupportsRuntimeObservation, } from '../../../providers/identity/runtime-observation.js';
+import { ZodError } from 'zod';
 const REQUEST_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/;
 const DISPATCH_LOCK_NAME = '.dispatch-lock';
 /**
@@ -48,7 +49,10 @@ function parseJournalEntry(fileName) {
  * written verbatim into the durable record by the same command.
  */
 export function redactDispatchMessage(message, roots = {}) {
-    let redacted = message;
+    // Secrets first: a rejected value is echoed by some validation messages (a
+    // Zod enum issue repeats what it received), so a secret-shaped value must be
+    // scrubbed here even though the same run also reports it as sensitive.
+    let redacted = redactSensitiveValues(message);
     const labelled = [
         ['<project>', roots.project],
         ['<repo>', roots.repo],
@@ -71,6 +75,8 @@ const OBSERVATION_SOURCE_BY_PROVIDER = {
     claude: CLAUDE_OBSERVATION_SOURCE,
 };
 const CALLER_ASSERTED_OBSERVATION_SOURCE = 'caller-asserted';
+/** A managed Claude record's provider is derived, and always this value. */
+const MANAGED_CLAUDE_PROVIDER = 'claude';
 function isRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
@@ -123,6 +129,139 @@ function resolveObservationEvent(record, event) {
         }),
     };
 }
+/**
+ * Project a caller-form `runtime-observation` event onto the shape the event
+ * schema checks, so the single-run pass reports its errors alongside every
+ * other stage instead of on a later run.
+ *
+ * The caller controls the envelope (`kind`, `requestId`, `source`, unknown
+ * keys) and either a finished `observation` or a `metadata` envelope, and
+ * both are checked here. The recording path derives an observation's
+ * `source`, `match`, and `comparedAxes` from the record, so those are filled
+ * with valid stand-ins rather than demanded from the caller; the metadata
+ * form's projection and request-correlation guard degrade to `not-reported`
+ * rather than fail, so they contribute no violation. The provider binding is
+ * checked directly: a managed record's provider is always `claude`.
+ */
+function runtimeObservationCallerForm(event, violations) {
+    if ('metadata' in event) {
+        if ('observation' in event) {
+            violations.push({
+                stage: 'event',
+                path: '<root>',
+                message: 'A runtime observation event carries either observation or metadata, not both.',
+            });
+        }
+        try {
+            parseRuntimeObservationEnvelope(event.metadata);
+        }
+        catch (error) {
+            if (error instanceof ZodError) {
+                violations.push(...zodIssueViolations('event', 'metadata', error));
+            }
+            else {
+                violations.push({
+                    stage: 'event',
+                    path: 'metadata',
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        const { metadata: _metadata, observation: _observation, ...rest } = event;
+        return { ...rest, observation: { status: 'not-reported' } };
+    }
+    const observation = event.observation;
+    if (!isRecord(observation) || observation.status !== 'reported') {
+        return event;
+    }
+    if (observation.provider !== MANAGED_CLAUDE_PROVIDER) {
+        violations.push({
+            stage: 'event',
+            path: 'observation.provider',
+            message: 'A runtime observation must name the same provider as its dispatch record.',
+        });
+    }
+    return {
+        ...event,
+        observation: {
+            ...observation,
+            provider: MANAGED_CLAUDE_PROVIDER,
+            source: CALLER_ASSERTED_OBSERVATION_SOURCE,
+            match: 'not-comparable',
+            comparedAxes: [],
+        },
+    };
+}
+/**
+ * Event violations for a managed input: the event must be an object, carry no
+ * sensitive content, satisfy the evidence-event schema, and name the same
+ * request as `recordBase`. Raw provider `metadata` entries are exempt from the
+ * sensitive walk exactly as on the recording path. A `runtime-observation`
+ * event is validated here too: `runtimeObservationCallerForm` projects its
+ * caller form onto the schema shape, filling the fields the recording path
+ * derives (source, match, compared axes) with valid stand-ins, so its errors
+ * join this single-run report.
+ */
+function collectManagedEventViolations(event, recordBase) {
+    if (!isRecord(event)) {
+        return [
+            {
+                stage: 'event',
+                path: '<root>',
+                message: 'Dispatch record event must be a JSON object.',
+            },
+        ];
+    }
+    const violations = [];
+    const walked = isRecord(event.metadata)
+        ? { ...event, metadata: { ...event.metadata, entries: null } }
+        : event;
+    violations.push(...collectSensitiveDispatchContent(walked, 'event').map((violation) => ({
+        stage: 'event',
+        path: violation.path.slice('event.'.length) || '<root>',
+        message: violation.message,
+    })));
+    const parsed = safeParseOatDispatchEvidenceEvent(event.kind === 'runtime-observation'
+        ? runtimeObservationCallerForm(event, violations)
+        : event);
+    if (!parsed.success) {
+        violations.push(...zodIssueViolations('event', null, parsed.error));
+    }
+    const recordRequestId = isRecord(recordBase) ? recordBase.request_id : null;
+    if (typeof event.requestId === 'string' &&
+        typeof recordRequestId === 'string' &&
+        event.requestId !== recordRequestId) {
+        violations.push({
+            stage: 'event',
+            path: 'requestId',
+            message: 'OAT event request ID must match the generic record.',
+        });
+    }
+    return violations;
+}
+/**
+ * The single-run pass for a managed Claude input. Every stage is validated
+ * independently and every violation is reported in one error, so a caller
+ * assembling the input fixes it in one round instead of one field per run.
+ * Checks that depend on a stage which failed to parse are skipped and named in
+ * the error; the recording path below still runs every check afterwards, so
+ * nothing this pass skips goes unchecked.
+ */
+function assertManagedClaudeInputValid(value) {
+    const launch = collectClaudeLaunchViolations(value.claudeLaunch);
+    const base = collectClaudeRecordBaseViolations(value.recordBase, launch.resolverRole);
+    const violations = [
+        ...launch.violations,
+        ...base.violations,
+        ...collectManagedEventViolations(value.event, value.recordBase),
+    ];
+    if (violations.length > 0) {
+        throw new ManagedClaudeDispatchValidationError(violations, [
+            ...launch.skipped,
+            ...base.skipped,
+        ]);
+    }
+}
 export function parseDispatchRecordInput(value) {
     if (!isRecord(value)) {
         throw new Error('Dispatch record input must be a JSON object.');
@@ -136,6 +275,9 @@ export function parseDispatchRecordInput(value) {
     if (!isGenericInput && !isManagedClaudeInput) {
         throw new Error('Dispatch record input accepts record and event, or claudeLaunch, event, and recordBase.');
     }
+    if (isManagedClaudeInput) {
+        assertManagedClaudeInputValid(value);
+    }
     if (!isRecord(value.event)) {
         throw new Error('Dispatch record event must be a JSON object.');
     }

package/dist/commands/shared/agents-md.d.ts

@@ -1,13 +1,16 @@
-import { lstat, readFile, readlink, realpath, writeFile } from 'node:fs/promises';
+import { lstat, open, readFile, readlink, realpath, writeFile } from 'node:fs/promises';
 /**
  * Plans repository AGENTS.md guidance without replacing existing paths.
  *
- * An absent root file may be created with one exclusive write. Existing files
- * and contained symlinks are read only: matching content returns no-change and
- * every required change is returned as a copy-pasteable manual patch.
+ * An absent root file may be created with one exclusive write. For an existing
+ * file (or its contained symlink target), matching content returns no-change,
+ * absent managed blocks are appended with one append-only write that never
+ * truncates, renames, or rewrites existing bytes, and a present-but-different
+ * block is returned as a zero-write, copy-pasteable manual patch.
  */
 export interface AgentsMdFileSystem {
     lstat: typeof lstat;
+    open: typeof open;
     readFile: typeof readFile;
     readlink: typeof readlink;
     realpath: typeof realpath;
@@ -22,6 +25,11 @@ export interface AgentsMdManualPatch {
     managedBlock: string;
     legacyBlockAction: 'preserve' | 'remove-manually';
     instructions: readonly string[];
+    /**
+     * Present when OAT refused to append absent blocks (zero bytes written);
+     * names the cause so callers do not claim an existing block differs.
+     */
+    appendRefusal?: string;
 }
 export interface AgentsMdBlocked {
     code: 'blocked';
@@ -30,7 +38,7 @@ export interface AgentsMdBlocked {
     action: string;
 }
 export interface UpsertSectionResult {
-    action: 'created' | 'no-change' | 'manual-required' | 'blocked';
+    action: 'created' | 'appended' | 'no-change' | 'manual-required' | 'blocked';
     manualPatch?: AgentsMdManualPatch;
     blocked?: AgentsMdBlocked;
 }
@@ -38,8 +46,21 @@ export interface AgentsMdSectionInput {
     key: string;
     body: string;
 }
+/**
+ * Renders one managed block exactly as the writer creates or appends it, so
+ * read-only surfaces print the same bytes the writer would produce.
+ */
+export declare function buildAgentsMdManagedBlock(key: string, body: string): string;
 export declare function formatAgentsMdMutationFailure(error: unknown): string;
 export declare function formatAgentsMdGuidanceResult(result: UpsertSectionResult): readonly string[];
+/**
+ * Open flags for the append-only write. A write access mode is required:
+ * `O_APPEND | O_NOFOLLOW` alone opens read-only and the write fails with
+ * `EBADF`. `O_NOFOLLOW` refuses a symlink swapped in at the final component,
+ * and `O_NONBLOCK` makes a FIFO swapped in fail fast (`ENXIO`) instead of
+ * hanging; it has no effect on regular-file writes.
+ */
+export declare const AGENTS_MD_APPEND_FLAGS: number;
 export declare function upsertAgentsMdSections(repoRoot: string, sections: readonly AgentsMdSectionInput[], options?: Pick<AgentsMdMutationOptions, 'fileSystem'>): Promise<Record<string, UpsertSectionResult>>;
 export declare function upsertAgentsMdSection(repoRoot: string, key: string, body: string, options?: AgentsMdMutationOptions): Promise<UpsertSectionResult>;
 export declare function removeAgentsMdSection(repoRoot: string, key: string, options?: Pick<AgentsMdMutationOptions, 'fileSystem'>): Promise<boolean | 'manual-required' | 'blocked'>;

package/dist/commands/shared/agents-md.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agents-md.d.ts","sourceRoot":"","sources":["../../../src/commands/shared/agents-md.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,SAAS,EACV,MAAM,kBAAkB,CAAC;AAG1B;;;;;;GAMG;AAEH,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,OAAO,KAAK,CAAC;IACpB,QAAQ,EAAE,OAAO,QAAQ,CAAC;IAC1B,QAAQ,EAAE,OAAO,QAAQ,CAAC;IAC1B,QAAQ,EAAE,OAAO,QAAQ,CAAC;IAC1B,SAAS,EAAE,OAAO,SAAS,CAAC;CAC7B;AAED,MAAM,WAAW,uBAAuB;IACtC,UAAU,CAAC,EAAE,kBAAkB,CAAC;IAChC,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAgCD,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,UAAU,GAAG,iBAAiB,CAAC;IAClD,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CACjC;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,SAAS,GAAG,WAAW,GAAG,iBAAiB,GAAG,SAAS,CAAC;IAChE,WAAW,CAAC,EAAE,mBAAmB,CAAC;IAClC,OAAO,CAAC,EAAE,eAAe,CAAC;CAC3B;AAED,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd;AAmTD,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAGpE;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,mBAAmB,GAC1B,SAAS,MAAM,EAAE,CAoBnB;AA4ID,wBAAsB,sBAAsB,CAC1C,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,SAAS,oBAAoB,EAAE,EACzC,OAAO,GAAE,IAAI,CAAC,uBAAuB,EAAE,YAAY,CAAM,GACxD,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAS9C;AAED,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,mBAAmB,CAAC,CAS9B;AAED,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,IAAI,CAAC,uBAAuB,EAAE,YAAY,CAAM,GACxD,OAAO,CAAC,OAAO,GAAG,iBAAiB,GAAG,SAAS,CAAC,CAYlD"}
+{"version":3,"file":"agents-md.d.ts","sourceRoot":"","sources":["../../../src/commands/shared/agents-md.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,SAAS,EACV,MAAM,kBAAkB,CAAC;AAG1B;;;;;;;;GAQG;AAEH,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,OAAO,KAAK,CAAC;IACpB,IAAI,EAAE,OAAO,IAAI,CAAC;IAClB,QAAQ,EAAE,OAAO,QAAQ,CAAC;IAC1B,QAAQ,EAAE,OAAO,QAAQ,CAAC;IAC1B,QAAQ,EAAE,OAAO,QAAQ,CAAC;IAC1B,SAAS,EAAE,OAAO,SAAS,CAAC;CAC7B;AAED,MAAM,WAAW,uBAAuB;IACtC,UAAU,CAAC,EAAE,kBAAkB,CAAC;IAChC,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAmCD,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,UAAU,GAAG,iBAAiB,CAAC;IAClD,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,WAAW,GAAG,iBAAiB,GAAG,SAAS,CAAC;IAC7E,WAAW,CAAC,EAAE,mBAAmB,CAAC;IAClC,OAAO,CAAC,EAAE,eAAe,CAAC;CAC3B;AAED,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd;AAcD;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE3E;AAySD,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAGpE;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,mBAAmB,GAC1B,SAAS,MAAM,EAAE,CAoBnB;AAmDD;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,QAIb,CAAC;AA+RvB,wBAAsB,sBAAsB,CAC1C,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,SAAS,oBAAoB,EAAE,EACzC,OAAO,GAAE,IAAI,CAAC,uBAAuB,EAAE,YAAY,CAAM,GACxD,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAS9C;AAED,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,mBAAmB,CAAC,CAS9B;AAED,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,IAAI,CAAC,uBAAuB,EAAE,YAAY,CAAM,GACxD,OAAO,CAAC,OAAO,GAAG,iBAAiB,GAAG,SAAS,CAAC,CAYlD"}

package/dist/commands/shared/agents-md.js

@@ -1,7 +1,9 @@
-import { lstat, readFile, readlink, realpath, writeFile, } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { lstat, open, readFile, readlink, realpath, writeFile, } from 'node:fs/promises';
 import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 const defaultFileSystem = {
     lstat,
+    open,
     readFile,
     readlink,
     realpath,
@@ -16,6 +18,13 @@ function sectionEnd(key) {
 function buildSection(key, body) {
     return `${sectionStart(key)}\n${body}\n${sectionEnd(key)}`;
 }
+/**
+ * Renders one managed block exactly as the writer creates or appends it, so
+ * read-only surfaces print the same bytes the writer would produce.
+ */
+export function buildAgentsMdManagedBlock(key, body) {
+    return buildSection(key, body);
+}
 function identityOf(stat) {
     return { device: String(stat.dev), inode: String(stat.ino) };
 }
@@ -120,6 +129,7 @@ async function planAgentsMd(repoRoot, fileSystem) {
             kind: 'file',
             agentsIdentity: identityOf(agentsStat),
             targetIdentity: identityOf(agentsStat),
+            targetLinkCount: Number(agentsStat.nlink),
         };
     }
     if (!agentsStat.isSymbolicLink()) {
@@ -158,6 +168,7 @@ async function planAgentsMd(repoRoot, fileSystem) {
         kind: 'symlink',
         agentsIdentity: identityOf(agentsStat),
         targetIdentity: identityOf(targetStat),
+        targetLinkCount: Number(targetStat.nlink),
         linkText,
     };
 }
@@ -212,7 +223,7 @@ function safeReason(error) {
     if (!(error instanceof Error)) {
         return 'AGENTS.md guidance could not be planned safely.';
     }
-    if (/^(Repository root|Repository-root AGENTS\.md|Repository or AGENTS\.md|AGENTS\.md section|AGENTS\.md managed sections|AGENTS\.md content)/.test(error.message)) {
+    if (/^(Repository root|Repository-root AGENTS\.md|Repository or AGENTS\.md|AGENTS\.md section|AGENTS\.md managed sections|AGENTS\.md content|AGENTS\.md append)/.test(error.message)) {
         return error.message;
     }
     return 'AGENTS.md guidance could not be planned safely.';
@@ -253,13 +264,19 @@ export function formatAgentsMdGuidanceResult(result) {
     }
     return [];
 }
-function createManualPatch(plan, managedBlocks, legacyKeys) {
+function createManualPatch(plan, managedBlocks, legacyKeys, appendRefusal) {
     const target = targetIdentifier(plan);
     return {
         target,
         managedBlock: managedBlocks.join('\n\n'),
         legacyBlockAction: legacyKeys.length > 0 ? 'remove-manually' : 'preserve',
+        ...(appendRefusal ? { appendRefusal } : {}),
         instructions: [
+            ...(appendRefusal
+                ? [
+                    `OAT did not append to ${target}: ${appendRefusal}. Nothing was written.`,
+                ]
+                : []),
             `Open ${target}.`,
             'Replace each matching OAT managed block, or append each absent block, exactly as shown.',
             ...(legacyKeys.length > 0
@@ -287,6 +304,121 @@ async function createMissingFile(plan, content, fileSystem) {
         return 'blocked';
     }
 }
+/**
+ * Open flags for the append-only write. A write access mode is required:
+ * `O_APPEND | O_NOFOLLOW` alone opens read-only and the write fails with
+ * `EBADF`. `O_NOFOLLOW` refuses a symlink swapped in at the final component,
+ * and `O_NONBLOCK` makes a FIFO swapped in fail fast (`ENXIO`) instead of
+ * hanging; it has no effect on regular-file writes.
+ */
+export const AGENTS_MD_APPEND_FLAGS = constants.O_WRONLY |
+    constants.O_APPEND |
+    constants.O_NOFOLLOW |
+    constants.O_NONBLOCK;
+const HARD_LINK_REFUSAL = 'the file has more than one hard link, so an append could change another path';
+function describeErrorCode(error) {
+    switch (errorCode(error)) {
+        case 'EACCES':
+        case 'EPERM':
+            return 'permission denied';
+        case 'EROFS':
+            return 'read-only file system';
+        case 'ENOSPC':
+            return 'no space left on device';
+        case 'EDQUOT':
+            return 'disk quota exceeded';
+        case undefined:
+            return 'unexpected error';
+        default:
+            return `error ${errorCode(error)}`;
+    }
+}
+const IDENTITY_CHANGED = 'Repository or AGENTS.md identity changed during planning.';
+/**
+ * Appends absent managed blocks to an existing, already-approved target.
+ *
+ * The opened handle's device/inode must equal the planned target identity, so
+ * a target swapped in after planning (for example a hard link to a file
+ * outside the repository renamed over AGENTS.md) is refused with zero bytes
+ * written. A handle with more than one hard link is refused the same way, and
+ * a non-regular file is blocked. The payload always starts with one newline,
+ * so the first marker starts its own line however the file (or a concurrent
+ * writer) ended, and `O_APPEND` places it after every byte already there.
+ */
+async function appendAbsentSections(plan, blocks, fileSystem) {
+    let handle;
+    try {
+        handle = await fileSystem.open(plan.targetPath, AGENTS_MD_APPEND_FLAGS);
+    }
+    catch (error) {
+        const code = errorCode(error);
+        // The planned path was a regular file; any of these means something else
+        // now sits at it (a symlink, a directory, or nothing), so it is an
+        // identity change, not a write refusal. EMLINK is the BSD O_NOFOLLOW
+        // error for a symlink.
+        if (code === 'ELOOP' ||
+            code === 'EMLINK' ||
+            code === 'ENOENT' ||
+            code === 'EISDIR' ||
+            code === 'ENOTDIR') {
+            return { kind: 'blocked', reason: IDENTITY_CHANGED };
+        }
+        if (code === 'ENXIO') {
+            return {
+                kind: 'blocked',
+                reason: 'AGENTS.md append target is not a regular file.',
+            };
+        }
+        return { kind: 'refused', cause: describeErrorCode(error) };
+    }
+    let outcome;
+    let offset = 0;
+    const payload = Buffer.from(`\n${blocks.join('\n\n')}\n`, 'utf8');
+    try {
+        const opened = await handle.stat();
+        if (!opened.isFile()) {
+            outcome = {
+                kind: 'blocked',
+                reason: 'AGENTS.md append target is not a regular file.',
+            };
+        }
+        else if (!hasIdentity(opened, plan.targetIdentity)) {
+            outcome = { kind: 'blocked', reason: IDENTITY_CHANGED };
+        }
+        else if (Number(opened.nlink) !== 1) {
+            outcome = { kind: 'refused', cause: HARD_LINK_REFUSAL };
+        }
+        else {
+            while (offset < payload.length) {
+                const { bytesWritten } = await handle.write(payload, offset, payload.length - offset);
+                if (bytesWritten <= 0) {
+                    throw Object.assign(new Error('Append wrote no bytes.'), {
+                        code: 'EIO',
+                    });
+                }
+                offset += bytesWritten;
+            }
+            outcome = { kind: 'appended' };
+        }
+    }
+    catch (error) {
+        outcome =
+            offset === 0
+                ? { kind: 'refused', cause: describeErrorCode(error) }
+                : {
+                    kind: 'blocked',
+                    reason: `AGENTS.md append stopped after writing part of the managed block (${describeErrorCode(error)}); the file may now end with a partial OAT block. Remove the partial block by hand, then rerun.`,
+                };
+    }
+    try {
+        await handle.close();
+    }
+    catch {
+        // Every byte is already written (or the outcome is already a refusal); a
+        // close error does not change what the file contains.
+    }
+    return outcome;
+}
 async function upsertSectionsInternal(repoRoot, sections, removeSectionKeys, fileSystem, allowReplan) {
     let plan;
     try {
@@ -332,6 +464,53 @@ async function upsertSectionsInternal(repoRoot, sections, removeSectionKeys, fil
         if (changed.length === 0 && legacy.length === 0) {
             return Object.fromEntries(desired.map(({ key }) => [key, { action: 'no-change' }]));
         }
+        // Appending cannot remove a legacy block, so any legacy block keeps the
+        // whole request on the zero-write manual patch.
+        if (legacy.length === 0) {
+            const absent = managed.filter(({ range }) => !range);
+            const different = managed.filter(({ block, range }) => range !== undefined &&
+                content.slice(range.start, range.end) !== block);
+            let appendRefusal;
+            if (absent.length > 0) {
+                if (plan.targetLinkCount !== 1) {
+                    appendRefusal = HARD_LINK_REFUSAL;
+                }
+                else {
+                    const appended = await appendAbsentSections(plan, absent.map(({ block }) => block), fileSystem);
+                    if (appended.kind === 'blocked')
+                        throw new Error(appended.reason);
+                    if (appended.kind === 'refused')
+                        appendRefusal = appended.cause;
+                }
+            }
+            if (appendRefusal !== undefined) {
+                // Zero bytes were written: every absent or different block goes on
+                // one manual patch that names why OAT did not append.
+                const refusalPatch = createManualPatch(plan, managed
+                    .filter(({ block, range }) => !range || content.slice(range.start, range.end) !== block)
+                    .map(({ block }) => block), [], appendRefusal);
+                return Object.fromEntries(managed.map(({ key, range }) => [
+                    key,
+                    range && !different.some((entry) => entry.key === key)
+                        ? { action: 'no-change' }
+                        : { action: 'manual-required', manualPatch: refusalPatch },
+                ]));
+            }
+            const differentPatch = different.length > 0
+                ? createManualPatch(plan, different.map(({ block }) => block), [])
+                : undefined;
+            return Object.fromEntries(managed.map(({ key, range }) => {
+                if (!range)
+                    return [key, { action: 'appended' }];
+                if (differentPatch && different.some((entry) => entry.key === key)) {
+                    return [
+                        key,
+                        { action: 'manual-required', manualPatch: differentPatch },
+                    ];
+                }
+                return [key, { action: 'no-change' }];
+            }));
+        }
         const manualPatch = createManualPatch(plan, changed.length > 0
             ? changed.map(({ block }) => block)
             : desired.map(({ block }) => block), legacy.map(({ key }) => key));

package/dist/commands/sync/apply.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/apply.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAoB3D,OAAO,KAAK,EACV,aAAa,EACb,uBAAuB,EAExB,MAAM,cAAc,CAAC;AA6XtB,wBAAsB,YAAY,CAChC,OAAO,EAAE,cAAc,EACvB,UAAU,EAAE,aAAa,EAAE,EAC3B,YAAY,EAAE,uBAAuB,GACpC,OAAO,CAAC,IAAI,CAAC,CAyMf"}
+{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/apply.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAoB3D,OAAO,KAAK,EACV,aAAa,EACb,uBAAuB,EAExB,MAAM,cAAc,CAAC;AAwYtB,wBAAsB,YAAY,CAChC,OAAO,EAAE,cAAc,EACvB,UAAU,EAAE,aAAa,EAAE,EAC3B,YAAY,EAAE,uBAAuB,GACpC,OAAO,CAAC,IAAI,CAAC,CA0Mf"}