create-agdf 0.20.1 → 0.20.2

package/lib/mcp-lifecycle/adapters/opencode.js

@@ -1,4 +1,4 @@
-import { existsSync, rmSync } from "node:fs";
+import { existsSync, readFileSync, rmSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import {
@@ -6,7 +6,6 @@ import {
   atomicWrite,
   fileSnapshot,
   inheritedPermissionEffect,
-  readJsonObject,
   referenceIdentityForSurface,
   restoreSnapshot,
 } from "./file-utils.js";
@@ -15,8 +14,75 @@ const OWNER = "create-agdf:mcp-runtime";
 const CREATED_CONFIG = "AGDF_MCP_CREATED_CONFIG";
 const SCHEMA = "https://opencode.ai/config.json";
 
+// Preserve offsets: comments and trailing commas are syntax, never string data.
+function jsonc(content) {
+  const tokens = [], clean = content.split('');
+  for (const match of content.matchAll(/"(?:\\[\s\S]|[^"\\])*"|\/\/[^\r\n]*|\/\*[\s\S]*?\*\/|[{}\[\]:,]|[^\s{}\[\]:,/"']+|[^\s]/gu)) {
+    const text = match[0], start = match.index, end = start + text.length;
+    if (text.startsWith('//') || text.startsWith('/*')) {
+      for (let i = start; i < end; ++i) if (!/[\r\n]/u.test(clean[i])) clean[i] = ' ';
+    } else tokens.push({ text, start, end });
+  }
+  for (let i = 0; i < tokens.length - 1; ++i) {
+    if (i > 0 && tokens[i].text === ',' && ['}', ']'].includes(tokens[i + 1].text)
+      && !['{', '[', ':', ','].includes(tokens[i - 1].text)) clean[tokens[i].start] = ' ';
+  }
+  const sanitized = clean.join(''), config = JSON.parse(sanitized);
+  let cursor = 0;
+  function node() {
+    const first = tokens[cursor++], properties = [];
+    if (!['{', '['].includes(first.text)) return { ...first };
+    const object = first.text === '{', close = object ? '}' : ']';
+    while (tokens[cursor].text !== close) {
+      const key = object ? tokens[cursor++] : null;
+      if (object) ++cursor; // colon; JSON.parse already validated the grammar
+      const value = node(), comma = tokens[cursor].text === ',' ? tokens[cursor++] : null;
+      if (object) {
+        const name = JSON.parse(key.text);
+        if (properties.some(row => row.name === name)) throw Error('duplicate_key');
+        properties.push({ name, start: key.start, value, comma });
+      }
+    }
+    return { start: first.start, end: tokens[cursor++].end, ...(object ? { properties } : {}) };
+  }
+  return { config, tree: node(), preserveSyntax: sanitized !== content };
+}
+
+function editJsonc(content, path, value) {
+  let { tree } = jsonc(content);
+  for (let i = 0; i < path.length; ++i) {
+    if (!tree.properties) throw Error('invalid_object');
+    const index = tree.properties.findIndex(row => row.name === path[i]), property = tree.properties[index];
+    if (property && i < path.length - 1) { tree = property.value; continue; }
+    const edits = [];
+    if (property) {
+      if (value !== undefined) edits.push([property.value.start, property.value.end, JSON.stringify(value, null, 2)]);
+      else {
+        edits.push([property.start, property.comma?.end ?? property.value.end, '']);
+        const previous = tree.properties[index - 1]?.comma;
+        if (!property.comma && previous) edits.push([previous.start, previous.end, '']);
+      }
+    } else {
+      if (value === undefined) return content;
+      for (const key of path.slice(i + 1).reverse()) value = { [key]: value };
+      const last = tree.properties.at(-1);
+      if (last && !last.comma) edits.push([last.value.end, last.value.end, ',']);
+      edits.push([tree.end - 1, tree.end - 1, `\n${'  '.repeat(i + 1)}${JSON.stringify(path[i])}: ${JSON.stringify(value, null, 2)}\n${'  '.repeat(i)}`]);
+    }
+    for (const [start, end, text] of edits.sort((a, b) => b[0] - a[0])) content = content.slice(0, start) + text + content.slice(end);
+    return content;
+  }
+  throw Error('invalid_path');
+}
+
 function readConfig(path) {
-  const value = readJsonObject(path, "AGDF_MCP_OPENCODE_CONFIG_INVALID");
+  let value;
+  try {
+    const content = existsSync(path) ? readFileSync(path, 'utf8') : '{}';
+    const parsed = jsonc(content);
+    value = { content, config: parsed.config, preserveSyntax: path.endsWith('.jsonc') || parsed.preserveSyntax };
+    if (!value.config || typeof value.config !== 'object' || Array.isArray(value.config)) throw Error('invalid');
+  } catch { throw Error('AGDF_MCP_OPENCODE_CONFIG_INVALID'); }
   if (value.config.mcp !== undefined && (!value.config.mcp || typeof value.config.mcp !== "object" || Array.isArray(value.config.mcp))) {
     throw new Error("AGDF_MCP_OPENCODE_CONFIG_INVALID");
   }
@@ -64,13 +130,26 @@ function inspectPath(path, expected) {
 }
 
 function sources({ scope, target, env }) {
+  const user = env.OPENCODE_CONFIG_DIR || join(homedir(), '.config', 'opencode');
+  const files = (id, directory, priority) => {
+    const paths = ['opencode.jsonc', 'opencode.json'].map(name => join(directory, name)).filter(existsSync);
+    if (!paths.length) paths.push(join(directory, 'opencode.json'));
+    // JSONC wins conflicting keys. Otherwise update the file owning the entry,
+    // rather than silently shadowing it by creating a second registration.
+    const selected = paths.find(path => {
+      const { config } = readConfig(path);
+      return config.mcp?.agdf !== undefined || config.mcp?.servers?.agdf !== undefined;
+    }) ?? paths[0];
+    return paths.map((path, index) => ({ id: path === selected ? id : `${id}_${path.endsWith('.jsonc') ? 'jsonc' : 'json'}`,
+      path, priority: priority + index, selected: scope === id && path === selected }));
+  };
   return [
     ...(typeof env.OPENCODE_CONFIG_CONTENT === "string" && env.OPENCODE_CONFIG_CONTENT.trim()
       ? [{ id: "inline", path: "env:OPENCODE_CONFIG_CONTENT", priority: 0, selected: false, inline: env.OPENCODE_CONFIG_CONTENT }] : []),
     ...(typeof env.OPENCODE_CONFIG === "string" && env.OPENCODE_CONFIG.trim()
       ? [{ id: "custom", path: env.OPENCODE_CONFIG, priority: 5, selected: false }] : []),
-    { id: "project", path: join(target, "opencode.json"), priority: 10, selected: scope === "project" },
-    { id: "user", path: join(env.OPENCODE_CONFIG_DIR || join(homedir(), ".config", "opencode"), "opencode.json"), priority: 20, selected: scope === "user" },
+    ...files('project', target, 10),
+    ...files('user', user, 20),
   ];
 }
 
@@ -80,7 +159,7 @@ function inspect(input) {
   const states = new Map(list.map((source) => {
     if (!source.inline) return [source.id, inspectPath(source.path, input.spec)];
     try {
-      const config = JSON.parse(source.inline);
+      const config = jsonc(source.inline).config;
       if (!config || typeof config !== "object" || Array.isArray(config)) throw new Error("invalid");
       return [source.id, inspectConfig(config, source.path, input.spec)];
     } catch { return [source.id, { status: "invalid", path: source.path, identity: null }]; }
@@ -96,7 +175,7 @@ function transaction({ action, scope, target, spec, previousSpec, env }) {
     return { status: "unchanged", path: current.path, apply() {}, rollback() {} };
   }
   const snapshot = fileSnapshot(current.path);
-  const { config } = readConfig(current.path);
+  const { config, content, preserveSyntax } = readConfig(current.path);
   const mcp = { ...(config.mcp ?? {}) };
   const nested = spec.host?.config_variant === "nested_v2";
   const createdConfig = !snapshot.existed || current.created_config === true;
@@ -117,7 +196,17 @@ function transaction({ action, scope, target, spec, previousSpec, env }) {
   const remaining = Object.keys(next);
   const removable = current.created_config === true
     && (remaining.length === 0 || (remaining.length === 1 && remaining[0] === "$schema" && next.$schema === SCHEMA));
-  const after = action === "disable" && removable ? null : `${JSON.stringify(next, null, 2)}\n`;
+  let after = `${JSON.stringify(next, null, 2)}\n`;
+  if (snapshot.existed && preserveSyntax) {
+    after = content;
+    for (const keys of [['mcp', 'agdf'], ['mcp', 'servers', 'agdf'], ['mcp', 'servers'], ['mcp']]) {
+      const beforeValue = keys.reduce((row, key) => row?.[key], config), nextValue = keys.reduce((row, key) => row?.[key], next);
+      if ((keys.length > 2 || keys.at(-1) === 'agdf' || nextValue === undefined) && JSON.stringify(beforeValue) !== JSON.stringify(nextValue)) {
+        after = editJsonc(after, keys, nextValue);
+      }
+    }
+  }
+  if (action === 'disable' && removable) after = null;
   return { status: "changed", path: current.path,
     apply() { if (after === null) rmSync(current.path, { force: true }); else atomicWrite(current.path, after); },
     rollback() { restoreSnapshot(snapshot); },

package/lib/mcp-lifecycle/profile.js

@@ -1,4 +1,5 @@
 import { mcpQualificationFields, validateMcpQualificationRecord } from "./evidence.js";
+import { SKILL_DISPATCH_FUNCTION_DEFINITION } from '#agdf-core/skill-dispatch/contract.js';
 
 const CAPABILITY_STATES = new Set(["supported", "manual_compatible", "unavailable", "unsupported", "unverified"]);
 const REGISTRATION_STATES = new Set(["absent", "matched", "foreign", "owned_mismatch", "precedence_conflict", "invalid"]);
@@ -26,7 +27,7 @@ export function validateMcpCapabilityProfile(profile, { expectedVersion } = {})
   if (profile?.tool?.semantic_owner !== "packages/core/lib/skill-dispatch/contract.js") errors.push("semantic_owner");
   if (Object.hasOwn(profile?.tool ?? {}, "description") || Object.hasOwn(profile?.tool ?? {}, "input_schema")
       || Object.hasOwn(profile?.tool ?? {}, "output_schema")) errors.push("duplicated_tool_semantics");
-  if (profile?.tool?.authorizes !== false || profile?.tool?.read_only !== true) errors.push("tool_boundary");
+  if (profile?.tool?.authorizes !== false || profile?.tool?.read_only !== SKILL_DISPATCH_FUNCTION_DEFINITION.annotations.readOnlyHint) errors.push("tool_boundary");
   if (profile?.package?.name !== "@agdf/mcp-server" || profile?.package?.sdk_server !== "2.0.0") errors.push("package");
   if (profile?.lifecycle?.owner !== "create-agdf" || profile?.lifecycle?.default_scope !== "project") errors.push("lifecycle");
   if (profile?.lifecycle?.result_contract_version !== 2) errors.push("result_contract_version");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-agdf",
-  "version": "0.20.1",
+  "version": "0.20.2",
   "description": "Install AGDF plugins, bootstrap supported repository surfaces and validate durable governance state.",
   "type": "module",
   "engines": {

package/runtime/core/lib/control-inspect/contract.js

@@ -14,7 +14,7 @@ import { ALL_ACTIVE_OPERATIONS, VARIANT_OPERATION, MODULE_OPERATION, CONTROL_INS
 
 export const CONTROL_INSPECT_SCHEMA_VERSION = "1";
 export const CONTROL_INSPECT_CONTRACT_VERSION = 1;
-// Every byte of this definition is loaded into every session on every host (SDD-005).
+// Shared discovery budget across hosts (SDD-005).
 export const CONTROL_INSPECT_MAX_DEFINITION_BYTES = 5000;
 export const OPERATION_CONTRACT_MODULES = Object.freeze(Object.entries(RUN_COMMAND_GROUPS)
   .flatMap(([group, kinds]) => kinds.map(kind => `${group}/${kind}`)));
@@ -25,28 +25,29 @@ function deepFreeze(value) {
   return Object.freeze(value);
 }
 
-// One field model supplies discovery, applicability guards and on-demand help.
+// Shared discovery, selector guards and on-demand help.
 export const PRESENTATION_OPERATIONS = Object.freeze(['presentation-document', 'presentation-preview']);
 export const BOUND_INSPECT_OPERATIONS = Object.freeze(['artifact-readiness', 'operation-contract', 'operation-status', 'native-qualification', ...PRESENTATION_OPERATIONS, 'runtime-generations']);
 export const PRESENTATION_CATALOG_MODULE = 'agdf_prepare/presentation.prepare';
 const uuidSchema = { type: 'string', pattern: REVISION_ID_PATTERN.source };
 const cursorSchema = { type: 'string', maxLength: 80, pattern: '^[0-9a-f]{64}:(?:0|[1-9][0-9]{0,6})$' };
 const fieldModel = {
-  operation: { help: 'Read-only operation; requirements below. Reads never prepare or approve a gate.', schema: { enum: [...CONTROL_INSPECT_OPERATIONS] }, description: 'Read action.' },
-  presentation_language: { help: 'Required BCP47 tag; valid unsupported languages use the complete English pack.', schema: { type: 'string', maxLength: 64, pattern: PRESENTATION_LANGUAGE_TAG_PATTERN_SOURCE }, description: 'Reply BCP47 tag.' },
-  working_directory: { help: 'Absolute execution context; it does not select a target.', schema: { type: 'string', minLength: 1, maxLength: 4096 }, description: 'Absolute context; not target authority.' },
-  target_source: { help: 'explicit_target: directly specified target; continued_target: confirmed continuation; current_repository: unambiguous current repository. Use actual provenance.', schema: { enum: [...TASK_TARGET_SOURCES] }, description: 'Paired target provenance.' },
-  primary_target: { help: 'Confirmed absolute project root, paired with target_source. working_directory never selects the target.', schema: { type: 'string', minLength: 1, maxLength: 4096 }, description: 'Confirmed absolute root.' },
-  run_id: { help: 'Use the named or unambiguously confirmed run; never select by recency.', schema: { type: 'string', pattern: RUN_ID_PATTERN.source }, description: 'Confirmed run.' },
-  gate: { help: 'Use the requested document gate; it is an optional catalog filter, not a selection heuristic. artifact-readiness accepts UR, PRD, SD or TP drafts only.', schema: { enum: [...APPROVAL_GATES] }, description: 'Draft/read gate; catalog filter.', operations: ['artifact-readiness', 'operation-contract', ...PRESENTATION_OPERATIONS] },
-  expected_revision_id: { help: 'For bound current-state inspections use the current gate-check revision. For document/preview reads preserve the selected prepared record original revision from catalog read_arguments or the original conversation binding.', schema: { $ref: '#/$defs/i' }, description: 'gate-check revision; original for reads.', operations: BOUND_INSPECT_OPERATIONS },
-  presentation_id: { help: 'Use the exact prepared ID from a validated catalog candidate or the existing conversation binding. Never guess a UUID, choose by timestamp, or prepare another presentation to pass a read.', schema: { $ref: '#/$defs/i' }, description: 'ID from catalog/conversation.', operations: PRESENTATION_OPERATIONS },
-  target_id: { help: 'Copy binding.target_id from operation-contract or the selected catalog read_arguments; this digest identifies a target and grants no authority.', schema: { type: 'string', pattern: '^sha256:[0-9a-f]{64}$' }, description: 'Target hash: operation-contract.', operations: PRESENTATION_OPERATIONS },
-  cursor: { help: 'Omit on the first page, then copy next_cursor unchanged. Catalog cursors are accepted only on operation-contract module=agdf_prepare/presentation.prepare. Never exchange document, preview or catalog cursors.', schema: cursorSchema, description: 'Next cursor; omit initially.', operations: [...PRESENTATION_OPERATIONS, 'operation-contract'] },
-  variant: { help: 'gate-check only: status-card or approval-envelope. Neither variant records an approval.', schema: { enum: [...GATE_CHECK_VARIANTS] }, description: 'gate-check view.', operations: [VARIANT_OPERATION] },
-  module: { help: 'contract uses an advertised runtime module; operation-contract uses group/kind; operation-status uses the original operation_id from the saved command receipt, never a newly generated UUID.', schema: { type: 'string', minLength: 1, maxLength: 64 }, description: 'Contract, group/kind or receipt UUID.', operations: [MODULE_OPERATION, 'operation-contract', 'operation-status'] },
-  all_active: { help: 'Only doctor and delivery-map accept true. False retains the selected-run read behavior.', schema: { type: 'boolean' }, description: 'All runs: doctor/delivery-map.' },
+  operation: { help: 'Read only; never prepare or approve.', schema: { enum: [...CONTROL_INSPECT_OPERATIONS] }, description: 'Read action.' },
+  presentation_language: { help: 'Required BCP47 tag; unsupported valid languages fall back to complete English.', schema: { type: 'string', maxLength: 64, pattern: PRESENTATION_LANGUAGE_TAG_PATTERN_SOURCE }, description: 'Reply BCP47 tag.' },
+  working_directory: { help: 'Absolute context; never selects a target.', schema: { type: 'string', minLength: 1, maxLength: 4096 }, description: 'Context; not target authority.' },
+  target_source: { help: 'Actual provenance: explicit_target = specified; continued_target = confirmed; current_repository = unambiguous.', schema: { enum: [...TASK_TARGET_SOURCES] }, description: 'Requires primary_target.' },
+  primary_target: { help: 'Confirmed absolute root paired with target_source; cwd is not target authority.', schema: { type: 'string', minLength: 1, maxLength: 4096 }, description: 'Pair: target_source.' },
+  run_id: { help: 'Named or confirmed Run; never select by recency.', schema: { type: 'string', pattern: RUN_ID_PATTERN.source }, description: 'Confirmed run.' },
+  gate: { help: 'Requested document gate or catalog filter, never a selection heuristic. artifact-readiness: UR/PRD/SD/TP only.', schema: { enum: [...APPROVAL_GATES] }, description: 'Document gate. Never with gate-check.', operations: ['artifact-readiness', 'operation-contract', ...PRESENTATION_OPERATIONS] },
+  expected_revision_id: { help: 'Bound inspections use current gate-check revision. Document/preview reads preserve the original selected catalog or conversation revision.', schema: { $ref: '#/$defs/i' }, description: 'gate-check revision; original for reads.', operations: BOUND_INSPECT_OPERATIONS },
+  presentation_id: { help: 'Exact prepared ID from validated catalog or conversation. Never guess, select by timestamp, or prepare a replacement to read.', schema: { $ref: '#/$defs/i' }, description: 'ID from catalog/conversation.', operations: PRESENTATION_OPERATIONS },
+  target_id: { help: 'Copy target hash from operation-contract binding or catalog read_arguments; never grants authority.', schema: { type: 'string', pattern: '^sha256:[0-9a-f]{64}$' }, description: 'Target hash: operation-contract.', operations: PRESENTATION_OPERATIONS },
+  cursor: { help: 'Omit initially; copy next_cursor. Catalog cursors: only operation-contract module=agdf_prepare/presentation.prepare. Never exchange cursor types.', schema: cursorSchema, description: 'Copy next_cursor.', operations: [...PRESENTATION_OPERATIONS, 'operation-contract'] },
+  variant: { help: 'gate-check view only; never records approval.', schema: { enum: [...GATE_CHECK_VARIANTS] }, description: 'gate-check view.', operations: [VARIANT_OPERATION] },
+  module: { help: 'contract: advertised module; operation-contract: group/kind; operation-status: original operation UUID from saved receipt, never a new UUID.', schema: { type: 'string', minLength: 1, maxLength: 64 }, description: 'Contract, group/kind or receipt UUID.', operations: [MODULE_OPERATION, 'operation-contract', 'operation-status'] },
+  all_active: { help: 'true: doctor/delivery-map only; false: selected Run.', schema: { type: 'boolean' }, description: 'All runs: doctor/delivery-map.' },
 };
+const selectorKeys = { gate: 'gate', expected_revision_id: 'expectedRevisionId', presentation_id: 'presentationId', target_id: 'targetId', cursor: 'cursor', variant: 'variant', module: 'contractModule' };
 const moduleOperations = [MODULE_OPERATION, 'operation-contract', 'operation-status'];
 const inputSchema = {
   type: 'object', additionalProperties: false,
@@ -69,9 +70,12 @@ const inputSchema = {
   ],
 };
 
+inputSchema.dependentSchemas.operation = { allOf: inputSchema.allOf };
+delete inputSchema.allOf;
+
 const inspectContract = {
   name: "agdf_inspect",
-  description: "Read-only: gate-check -> operation-contract module=agdf_prepare/presentation.prepare -> catalog read_arguments -> presentation-document/next_cursor.",
+  description: "Read-only. gate-check: language, cwd, target_source+primary_target, Run; omit gate/module. Follow navigation.next_calls sequentially; read all pages.",
   annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
   inputSchema,
   outputSchema: {
@@ -103,10 +107,7 @@ const inspectContract = {
   },
 };
 
-// Detailed result semantics remain owned here. The discovered tool advertises the
-// bounded envelope; repeating every forwarding branch in each model session is
-// unnecessary. Both declarations derive from this same contract, without a
-// second evaluator or a larger discovery budget.
+// Core retains full result validation; discovery advertises the bounded envelope.
 export const CONTROL_INSPECT_OUTPUT_SCHEMA = deepFreeze(inspectContract.outputSchema);
 export const CONTROL_INSPECT_FUNCTION_DEFINITION = deepFreeze({
   ...inspectContract,
@@ -134,7 +135,7 @@ export function inspectContractHelp() {
     examples: [ { ...base, operation: 'gate-check' },
       { ...base, operation: 'operation-contract', module: PRESENTATION_CATALOG_MODULE, expected_revision_id: revision, gate: 'UR' },
       { ...base, operation: 'presentation-document', expected_revision_id: revision, gate: 'UR', presentation_id: '00000000-0000-4000-8000-000000000002', target_id: `sha256:${'0'.repeat(64)}` } ],
-    provenance: 'Keep exact conversation bindings. Otherwise use catalog read_arguments only after unique complete discovery or explicit selection. Document revision is original, not current. Prepared is not human-viewed or approved. Other modules reject catalog cursors.',
+    provenance: 'Preserve exact conversation bindings; otherwise require unique complete catalog discovery or explicit selection. Reads keep original revisions. Prepared proves neither viewing nor approval. Catalog cursors require the catalog module.',
     catalog_limits: { page_candidates: 16, record_files: 256, record_bytes: 1048576, directory_entries: 1024 },
   });
 }
@@ -172,13 +173,7 @@ export function parseControlInspectFunctionArguments(argumentsValue, trustedCont
     targetSource: argumentsValue.target_source,
     primaryTarget: argumentsValue.primary_target,
     runId: argumentsValue.run_id,
-    ...(argumentsValue.gate !== undefined ? { gate: argumentsValue.gate } : {}),
-    ...(argumentsValue.expected_revision_id !== undefined ? { expectedRevisionId: argumentsValue.expected_revision_id } : {}),
-    ...(argumentsValue.presentation_id !== undefined ? { presentationId: argumentsValue.presentation_id } : {}),
-    ...(argumentsValue.target_id !== undefined ? { targetId: argumentsValue.target_id } : {}),
-    ...(argumentsValue.cursor !== undefined ? { cursor: argumentsValue.cursor } : {}),
-    ...(argumentsValue.variant !== undefined ? { variant: argumentsValue.variant } : {}),
-    ...(argumentsValue.module !== undefined ? { contractModule: argumentsValue.module } : {}),
+    ...Object.fromEntries(Object.entries(selectorKeys).filter(([field]) => argumentsValue[field] !== undefined).map(([field, key]) => [key, argumentsValue[field]])),
     ...(argumentsValue.all_active !== undefined ? { allActive: argumentsValue.all_active } : {}),
     surface: trustedContext.surface,
     expectedVersion: trustedContext.expectedVersion,
@@ -186,8 +181,7 @@ export function parseControlInspectFunctionArguments(argumentsValue, trustedCont
   });
 }
 
-// Normalizes a raw inspect input with the dispatcher's language and target rules and the shared
-// read-selection rules. Throws SkillDispatchInputError or ReadSelectionError; both carry `field`.
+// Shared language, target and read-selection rules; errors carry the invalid field.
 export function normalizeControlInspectInput(input) {
   const operation = requireText(input.operation, "operation", 64);
   if (!CONTROL_INSPECT_OPERATIONS.includes(operation)) throw new SkillDispatchInputError("operation", `Unsupported inspect operation: ${operation}`);
@@ -240,7 +234,6 @@ export function normalizeControlInspectInput(input) {
     contractModule: input.contractModule,
     variant: input.variant,
   });
-  const selectorKeys = { gate: 'gate', expected_revision_id: 'expectedRevisionId', presentation_id: 'presentationId', target_id: 'targetId', cursor: 'cursor', variant: 'variant', module: 'contractModule' };
   for (const [field, key] of Object.entries(selectorKeys)) {
     if (input[key] !== undefined && !fieldModel[field].operations.includes(operation)) throw new SkillDispatchInputError(field, `Unsupported selector for ${operation}`);
   }
@@ -269,8 +262,7 @@ export { ReadSelectionError };
 
 export const CONTROL_INSPECT_OUTPUT_TOO_LARGE_RECOVERY = "The inspect result exceeds the 1 MiB MCP output limit. Narrow the selection (one run_id instead of all_active) or use the CLI with --json.";
 
-// Same 1 MiB ceiling as the dispatcher, but the fallback keeps the inspect result shape so the host
-// receives a schema-valid recovery instead of a schema error.
+// Preserve the result envelope when enforcing the shared 1 MiB output ceiling.
 export function serializeControlInspectResult(result) {
   const output = JSON.stringify(result, null, 2);
   if (Buffer.byteLength(output, "utf8") <= SKILL_DISPATCH_MAX_OUTPUT_BYTES) return output;

package/runtime/core/lib/control-inspect/service.js

@@ -8,7 +8,7 @@ import { renderSkillDispatchInputRecovery, renderSkillDispatchRecovery, renderTa
 import { resolveTaskTarget, TaskTargetInputError } from "../task-target-resolution.js";
 import { SKILL_DISPATCH_PRESENTATION_LANGUAGE_RECOVERY, SkillDispatchInputError, emptySkillDispatchTiming } from "../skill-dispatch/contract.js";
 import { CONTROL_INSPECT_CONTRACT_VERSION, CONTROL_INSPECT_SCHEMA_VERSION, ReadSelectionError, normalizeControlInspectInput, inspectContractHelp, PRESENTATION_CATALOG_MODULE } from "./contract.js";
-import { operationContract } from '../control-state/run-command-contract.js';
+import { RUN_COMMAND_DESCRIPTORS, operationContract } from '../control-state/run-command-contract.js';
 import { inspectRunOperation } from '../control-state/run-operation-status.js';
 import { resolveControlCommandTarget } from '../control-state/approval-command-contract.js';
 import { readRunState } from '../control-evaluation/run-state.js';
@@ -22,11 +22,8 @@ import { sourceRevisionBoundary } from '../control-state/run-revision-boundary.j
 import { sourceRevisionQualityFacts } from '../control-state/run-source-revisions.js';
 import { readHistoryBytes } from '../control-state/run-revision-history.js';
 
-// The MCP read tool is a projection over the existing evaluators. It calls exactly the functions the
-// CLI handlers call and returns their --json report. Draft preflight additionally composes those
-// existing content validators through its read-only Core owner; it adds no CLI command. It never writes,
-// never selects a run on its own and never prepares an approval binding. Evaluators run with the
-// dispatcher's dependency set: no git child process, so verified_change git observation is absent.
+// Read-only projection of canonical CLI evaluators and Core validators. It never
+// writes, selects a Run or prepares approval. Git observations are unavailable.
 
 const defaultNow = () => process.hrtime.bigint();
 const milliseconds = (start, end) => Number(end - start) / 1_000_000;
@@ -200,7 +197,7 @@ export function createControlInspectService(dependencies = {}) {
         return bindHostAction(result);
       }
       const controlStarted = now();
-      const { report, presentation, invalidModule } = stage(DISPATCH_RECOVERY.control_evaluation_failed, () => {
+      const { report, presentation, invalidModule, navigation } = stage(DISPATCH_RECOVERY.control_evaluation_failed, () => {
         validateControlReadBoundary?.(target.governance_target);
         const selection = {
           ...(input.run_id ? { runId: input.run_id } : {}),
@@ -270,7 +267,27 @@ export function createControlInspectService(dependencies = {}) {
           case "gate-check": {
             const evaluate = () => gateCheck(target.governance_target, { ...selection, presentationLanguage: input.presentation_language });
             const evaluated = evaluate();
-            return { report: evaluated, presentation: gateCheckPresentation(evaluated, input.variant, evaluate) };
+            let navigation;
+            // Optional hints never replace the canonical report.
+            try {
+              if (input.run_id && input.target_source && input.primary_target && evaluated.status_card?.run_id === input.run_id) {
+                const revisionId = evaluated.status_card.runState?.meta?.revision_id;
+                const targetId = resolveControlCommandTarget(target.governance_target).target_id;
+                const common = Object.fromEntries(['presentation_language', 'working_directory', 'target_source', 'primary_target', 'run_id'].map(key => [key, input[key]]));
+                common.expected_revision_id = revisionId;
+                const catalog = readPresentationCatalog(target.governance_target, { runId: input.run_id, revisionId, targetId,
+                  gate: evaluated.current_gate, workingDirectory: input.working_directory, targetSource: input.target_source,
+                  primaryTarget: input.primary_target, language: input.presentation_language });
+                const kind = evaluated.next_operation?.operation_key;
+                const group = RUN_COMMAND_DESCRIPTORS[kind]?.group;
+                const nextCalls = catalog.state !== 'unavailable' && group ? [{ tool: 'agdf_inspect', arguments: {
+                  operation: 'operation-contract', ...common, module: `${group}/${kind}` } }] : [];
+                if (catalog.state === 'unique' && catalog.complete_scan && catalog.page_complete)
+                  nextCalls.push({ tool: 'agdf_inspect', arguments: catalog.candidates[0].read_arguments });
+                navigation = { presentation_catalog: catalog, next_calls: nextCalls };
+              }
+            } catch { /* Advisory navigation unavailable. */ }
+            return { report: evaluated, navigation, presentation: gateCheckPresentation(evaluated, input.variant, evaluate) };
           }
           case "delivery-map": {
             const evaluated = deliveryMap(target.governance_target, selection, deliveryMapDependencies);
@@ -299,6 +316,7 @@ export function createControlInspectService(dependencies = {}) {
       result.target = target;
       result.report = report;
       result.presentation = presentation;
+      if (navigation) result.navigation = navigation;
       timing.total_ms = round(milliseconds(started, now()));
       return bindHostAction(result);
     } catch (error) {

package/runtime/core/lib/control-state/run-command-contract.js

@@ -1,7 +1,7 @@
 import { UR_AUTHORING_FORMAT } from '../control-evaluation/ur-readiness.js';
 import { PRD_DECISION_FORMAT } from '../control-evaluation/prd-readiness.js';
 import { SD_DECISION_FORMAT } from '../control-evaluation/sd-readiness.js';
-import { DIGEST_PATTERN, canonicalJson, digest } from './approval-command-contract.js';
+import { DIGEST_PATTERN, COOPERATIVE_ASSURANCE, canonicalJson, digest } from './approval-command-contract.js';
 import { RUN_ID_PATTERN, REVISION_ID_PATTERN, APPROVAL_GATES } from './run-identity.js';
 import { TASK_TARGET_SOURCES } from '../task-target-resolution.js';
 import { PRESENTATION_LANGUAGE_TAG_PATTERN_SOURCE } from '../interaction-presentation.js';
@@ -73,14 +73,128 @@ function payloadSchema(group, kind) {
     original_kind: enumeration(Object.keys(recoveryGroups).filter(original => recoveryGroups[original] === group)) })
     : RUN_COMMAND_DESCRIPTORS[kind].payload_schema;
 }
+// Canonical help is shared by expanded Core validation and operation help.
+const fieldHelp = Object.freeze({
+  schema_version: 'Contract version 1.',
+  presentation_language: 'Response BCP 47 language, e.g. de.',
+  working_directory: 'Absolute task directory for target resolution.',
+  target_source: 'Human task basis for this target; cwd alone is not authority.',
+  primary_target: 'Confirmed absolute target from resolution.',
+  target_id: 'Exact hash from current MCP target inspection; never guess.',
+  run_id: 'Scope-matching Run from inspection; recency is not authority.',
+  expected_revision_id: 'Current inspected revision; recovery retains original binding.',
+  operation_id: 'New command UUID; after handoff reuse original UUID/exact payload.',
+  assurance: 'Cooperative intent, not human proof or approval.',
+  command: 'Kind/payload; nested help: operation-contract.',
+  path: 'Contained Run-local source path; read the actual file before recording.',
+  digest: 'Canonical SHA-256 of the exact source bytes; never guess or reseal unrelated edits.',
+  gate: 'Exact gate named by current control, not permission to advance it.',
+  presentation_id: 'Immutable current presentation id from MCP inspection or preparation.',
+  response: 'Forward the new deliberate human reply for this exact presentation.',
+  confirmation: 'Exact concrete confirmation required by this operation contract.',
+  source_gate: 'Earliest actually changed approved source, determined from the reviewed proposal.',
+  preview_digest: 'Exact preview digest returned for the same reviewed proposal and binding.',
+  recovery_revision_id: 'Revision allowed by the original pending operation recovery contract.',
+  pending_digest: 'Exact pending operation digest from authoritative operation-status.',
+  original_kind: 'Original operation kind in this fixed permission group; preserve its identity.',
+});
+function describeFields(schema) {
+  const value = { ...schema };
+  if (value.properties) value.properties = Object.fromEntries(Object.entries(value.properties).map(([key, child]) =>
+    [key, { ...describeFields(child), ...(fieldHelp[key] ? { description: fieldHelp[key] } : {}) }]));
+  for (const key of ['oneOf', 'anyOf', 'allOf']) if (value[key]) value[key] = value[key].map(describeFields);
+  return value;
+}
+function commandSchema(group) {
+  return { oneOf: RUN_COMMAND_GROUPS[group].map(kind => strictObject({ kind: { const: kind },
+    payload: { ...payloadSchema(group, kind), description: RUN_COMMAND_DESCRIPTORS[kind].effects.join('; ') } })) };
+}
 export function commandGroupSchema(group) {
-  const kinds = RUN_COMMAND_GROUPS[group]; if (!kinds) throw Error('command_group_unsupported');
-  return strictObject({ ...envelope, command: { oneOf: kinds.map(kind => strictObject({ kind: { const: kind }, payload: payloadSchema(group, kind) })) } });
+  if (!RUN_COMMAND_GROUPS[group]) throw Error('command_group_unsupported');
+  return describeFields(strictObject({ ...envelope, command: commandSchema(group) }));
+}
+// Repeated immutable schema nodes become deterministic local references. Only
+// schema positions are traversed: a properties map is never itself a schema.
+export function compactCommandSchema(expanded) {
+  const visit = (node, transform, depth = 0) => {
+    const copy = { ...node };
+    if (copy.properties) copy.properties = Object.fromEntries(Object.entries(copy.properties).map(([key, child]) =>
+      [key, visit(child, transform, depth + 1)]));
+    for (const key of ['oneOf', 'anyOf', 'allOf']) if (copy[key]) copy[key] = copy[key].map(child => visit(child, transform, depth + 1));
+    if (copy.items) copy.items = visit(copy.items, transform, depth + 1);
+    return transform(copy, depth);
+  };
+  // Discovery keeps direct envelope and per-operation payload meaning; nested
+  // field detail remains in the expanded operation-contract from this owner.
+  const discovery = visit(expanded, (node, depth) => {
+    if (depth > 1) delete node.description;
+    return node;
+  });
+  // Restore every payload's concise meaning explicitly, without phrase policy.
+  discovery.properties.command.oneOf.forEach((row, i) => { row.properties.payload.description = expanded.properties.command.oneOf[i].properties.payload.description; });
+  const counts = new Map();
+  visit(discovery, node => { const { description, ...base } = node; const key = JSON.stringify(base); counts.set(key, (counts.get(key) ?? 0) + 1); return node; });
+  const definitions = {}, names = new Map();
+  const factor = (node, depth = 0, defining = false) => {
+    const { description, ...base } = node;
+    const key = JSON.stringify(base);
+    if (!defining && depth > 0 && (counts.get(key) ?? 0) > 1 && key.length >= 48) {
+      if (!names.has(key)) {
+        const name = `s${names.size}`; names.set(key, name);
+        definitions[name] = factor(base, depth, true);
+      }
+      return { $ref: `#/$defs/${names.get(key)}`, ...(description ? { description } : {}) };
+    }
+    const copy = { ...node };
+    if (copy.properties) copy.properties = Object.fromEntries(Object.entries(copy.properties).map(([name, child]) => [name, factor(child, depth + 1)]));
+    for (const name of ['oneOf', 'anyOf', 'allOf']) if (copy[name]) copy[name] = copy[name].map(child => factor(child, depth + 1));
+    if (copy.items) copy.items = factor(copy.items, depth + 1);
+    return copy;
+  };
+  const projected = factor(discovery);
+  if (names.size) projected.$defs = definitions;
+  return projected;
 }
+const openObject = { type: 'object', additionalProperties: true };
+const nullableObject = { ...openObject, type: ['object', 'null'] };
+const nullableString = { type: ['string', 'null'] };
+const resultProperties = {
+  schema_version: { const: '1' }, outcome: enumeration(['accepted', 'already_applied', 'rejected', 'recovery_required', 'effect_unknown']), authorizes: { const: false },
+  reason: { ...nullableString, minLength: 1 }, operation_id: { ...identity, type: ['string', 'null'] }, request_digest: { ...hash, type: ['string', 'null'] },
+  binding: { ...nullableObject, properties: { target_id: hash, run_id: envelope.run_id, expected_revision_id: identity, kind: string() }, required: ['target_id', 'run_id', 'expected_revision_id', 'kind'] },
+  receipt: nullableObject, effect: nullableObject,
+  current: { ...nullableObject, properties: { available: { type: 'boolean' }, revision: { type: 'integer' }, revision_id: identity }, required: ['available'] },
+  assurance: { ...openObject, properties: Object.fromEntries(Object.entries(COOPERATIVE_ASSURANCE).map(([key, value]) => [key, { const: value }])), required: Object.keys(COOPERATIVE_ASSURANCE) }, family_result: openObject,
+  historical_effect: { type: 'boolean' }, dispatch: enumeration(['not_dispatched', 'unknown']), recovery: nullableString,
+  diagnostics: { type: 'array', items: openObject },
+  presentation_delivery: { ...openObject, properties: { mode: enumeration(['native_plus_chat', 'full_chat']), display: enumeration(['confirmed', 'unconfirmed']),
+    text: { type: 'string' }, presentation_id: identity, revision_id: identity, document_digest: hash, document_language: nullableString, authorizes: { const: false } },
+    required: ['mode', 'display', 'text', 'presentation_id', 'revision_id', 'document_digest', 'document_language', 'authorizes'] },
+  app_capability: { type: 'string' }, app_reason: { type: 'string' }, app_display: { type: 'string' },
+};
+const resultVariants = [
+  { properties: { outcome: enumeration(['accepted', 'already_applied']), operation_id: { type: 'string' }, request_digest: { type: 'string' }, binding: { type: 'object' }, current: { type: 'object' } }, required: ['operation_id', 'request_digest', 'binding', 'receipt', 'effect', 'current', 'assurance', 'historical_effect', 'recovery', 'reason', 'family_result'] },
+  { properties: { outcome: enumeration(['rejected', 'recovery_required', 'effect_unknown']), reason: { type: 'string', minLength: 1 } }, required: ['reason'] },
+];
+export const RUN_COMMAND_RESULT_SCHEMA = freeze({ type: 'object', additionalProperties: true, properties: resultProperties,
+  required: ['schema_version', 'outcome', 'authorizes'], oneOf: resultVariants,
+  allOf: [{ oneOf: [
+    { properties: { outcome: enumeration(['accepted', 'already_applied', 'rejected']) } },
+    { properties: { outcome: enumeration(['recovery_required', 'effect_unknown']), recovery: { type: 'string', minLength: 1 } }, required: ['operation_id', 'recovery'] },
+  ] }] });
+// Essential envelope projection from the full model, not a second result owner.
+export function commandResultSchema() {
+  const keys = ['schema_version', 'outcome', 'authorizes', 'reason', 'operation_id', 'binding', 'receipt', 'recovery'];
+  const properties = Object.fromEntries(keys.map(key => [key, key === 'binding' ? { type: resultProperties.binding.type } : key === 'outcome' ? { type: 'string' } : resultProperties[key]]));
+  return { type: 'object', properties, required: RUN_COMMAND_RESULT_SCHEMA.required,
+    oneOf: resultVariants.map(variant => ({ ...variant, properties: Object.fromEntries(Object.entries(variant.properties).filter(([key]) => keys.includes(key))), required: variant.required.filter(key => keys.includes(key)) })) };
+}
+export function validateRunCommandResult(value) { return schemaDiagnostics(value, RUN_COMMAND_RESULT_SCHEMA); }
 export function commandGroupDefinition(group) {
   const definition = { name: group,
-    description: `${group}: ${RUN_COMMAND_GROUPS[group]?.join(', ')}. Exact target/Run/revision/UUID required. Cooperative caller intent only; tool permission never approves a gate. Inspect operation-contract before use; retry original UUID via operation-status after uncertainty. No VCS.`,
-    annotations: { readOnlyHint: false, destructiveHint: group !== 'agdf_prepare', idempotentHint: false, openWorldHint: false }, inputSchema: commandGroupSchema(group) };
+    description: `${group}: ${RUN_COMMAND_GROUPS[group]?.join(', ')}. Inspect operation-contract for payloads/bindings. Cooperative intent never approves a gate. After uncertainty inspect operation-status with original UUID/payload. No VCS.`,
+    annotations: { readOnlyHint: false, destructiveHint: group !== 'agdf_prepare', idempotentHint: false, openWorldHint: false },
+    inputSchema: compactCommandSchema(commandGroupSchema(group)), outputSchema: commandResultSchema() };
   if (Buffer.byteLength(JSON.stringify(definition)) > RUN_COMMAND_LIMITS.definition_bytes) throw Error('command_definition_budget_exceeded');
   return freeze(definition);
 }
@@ -88,14 +202,31 @@ export function commandGroupDefinition(group) {
 // No caller validator, accessor execution, coercion or default-expanded effect is allowed.
 export function schemaDiagnostics(value, schema, path = '$') {
   const errors = [];
-  if (schema.oneOf) return schema.oneOf.filter(choice => schemaDiagnostics(value, choice, path).length === 0).length === 1 ? [] : [{ path, code: 'one_of_invalid' }];
+  if (schema.oneOf && schema.oneOf.filter(choice => schemaDiagnostics(value, choice, path).length === 0).length !== 1) errors.push({ path, code: 'one_of_invalid' });
+  if (schema.allOf) for (const choice of schema.allOf) errors.push(...schemaDiagnostics(value, choice, path));
+  if (Array.isArray(schema.type)) {
+    const matches = schema.type.map(type => schemaDiagnostics(value, { ...schema, type }, path));
+    return matches.some(result => result.length === 0) ? errors : [...errors, { path, code: 'type_invalid' }];
+  }
+  if (schema.type === 'null' && value !== null) errors.push({ path, code: 'null_required' });
+  if (schema.type === 'integer' && !Number.isInteger(value)) errors.push({ path, code: 'integer_required' });
+  if (schema.type === 'boolean' && typeof value !== 'boolean') errors.push({ path, code: 'boolean_required' });
+  if (schema.type === 'array') {
+    if (!Array.isArray(value)) return [...errors, { path, code: 'array_required' }];
+    for (let i = 0; i < value.length; i++) {
+      const field = Object.getOwnPropertyDescriptor(value, String(i));
+      if (!field || !Object.hasOwn(field, 'value')) errors.push({ path, code: 'accessor_forbidden' });
+      else if (schema.items) errors.push(...schemaDiagnostics(field.value, schema.items, `${path}[${i}]`));
+    }
+  }
   if (Object.hasOwn(schema, 'const') && value !== schema.const) errors.push({ path, code: 'constant_invalid' });
   if (schema.enum && !schema.enum.includes(value)) errors.push({ path, code: 'enum_invalid' });
-  if (schema.type === 'object') {
+  if (schema.type === 'object' || !schema.type && (schema.properties || schema.required) && value !== null && typeof value === 'object' && !Array.isArray(value)) {
     if (value === null || typeof value !== 'object' || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) return [{ path, code: 'object_required' }];
     const keys = Reflect.ownKeys(value);
     for (const key of keys) {
-      if (typeof key !== 'string' || !Object.hasOwn(schema.properties, key)) { errors.push({ path, code: 'unknown_field' }); continue; }
+      if (typeof key !== 'string') { errors.push({ path, code: 'unknown_field' }); continue; }
+      if (!Object.hasOwn(schema.properties ?? {}, key)) { if (schema.additionalProperties === false) errors.push({ path, code: 'unknown_field' }); continue; }
       const property = Object.getOwnPropertyDescriptor(value, key);
       if (!Object.hasOwn(property, 'value')) { errors.push({ path: `${path}.${key}`, code: 'accessor_forbidden' }); continue; }
       errors.push(...schemaDiagnostics(property.value, schema.properties[key], `${path}.${key}`));
@@ -122,7 +253,7 @@ export const runCommandRequestDigest = input => digest(`agdf-run-command/1\0${ca
 export function operationContract(group, kind, { gate } = {}) {
   if (!RUN_COMMAND_GROUPS[group]?.includes(kind)) return { available: false, reason: 'command_group_unsupported' };
   return { schema_version: RUN_COMMAND_VERSION, available: true, group, kind, ...RUN_COMMAND_DESCRIPTORS[kind], payload_schema: payloadSchema(group, kind),
-    schema: strictObject({ ...envelope, command: strictObject({ kind: { const: kind }, payload: payloadSchema(group, kind) }) }), retry_class: 'inspect_original_operation_after_dispatch', assurance: 'cooperative_local',
+    schema: describeFields(strictObject({ ...envelope, command: strictObject({ kind: { const: kind }, payload: { ...payloadSchema(group, kind), description: RUN_COMMAND_DESCRIPTORS[kind].effects.join('; ') } }) })), result_schema: RUN_COMMAND_RESULT_SCHEMA, retry_class: 'inspect_original_operation_after_dispatch', assurance: 'cooperative_local',
     reference_limits: { input_bytes: RUN_COMMAND_LIMITS.input_bytes, source_file_bytes: 131072, result_bytes: RUN_COMMAND_LIMITS.result_bytes },
     internal_result_formats: kind === 'step.record' ? { 'UX Intent Definition': UX_DECISION_FORMAT,
       reviews: { declaration: '- decision: pass | revise | block | not_applicable', result_scope: 'actual current owner report; no generated judgement or approval' } } : undefined,

package/runtime/core/lib/control-state/run-presentation-render.js

@@ -431,8 +431,8 @@ export function renderReviewableApproval(root, report, { runId, gate, revisionId
     german ? 'Antworte „Dokument lesen“, um diese Fassung vollständig im Chat zu lesen. Fragen und Änderungswünsche kannst du hier besprechen. Ohne deine Freigabe bleibt dieser Schritt offen.'
       : 'Reply “Read document” to read this complete version in Chat. Discuss questions and requested changes here. This step remains open until you approve.',
     pack.decisionCard.chatApprovalHint.replace('{gate}', gate),
-    `<details><summary>${german ? 'Details und Nachweise' : 'Details and evidence'}</summary>\n\n${summaryMarkdown}\n\n</details>`,
-    `<details><summary>${german ? 'Fassung und Quellen' : 'Version and sources'}</summary>\n\nRun: \`${runId}\` · ${pack.gateTitles[gate]} · Revision: \`${revisionId}\`\n\nSHA-256: \`${artefactDigest}\`\n\n</details>`];
+    `### ${german ? 'Details und Nachweise' : 'Details and evidence'}\n\n${summaryMarkdown}`,
+    `### ${german ? 'Fassung und Quellen' : 'Version and sources'}\n\nRun: \`${runId}\` · ${pack.gateTitles[gate]} · Revision: \`${revisionId}\`\n\nSHA-256: \`${artefactDigest}\``];
   return parts.every((part) => typeof part === "string" && part.trim())
     ? { markdown: parts.join("\n\n"), companion_markdown: [german
           ? `Die AGDF-Karte ist geöffnet. Du kannst dort „${qaAcceptance?.approve_label || 'Freigeben'}“ klicken oder hier \`Approval: ${gate}\` eingeben. Beide Wege entscheiden dieselbe vorgelegte Fassung einmal.`

package/runtime/core/lib/interaction-presentation.js

@@ -409,7 +409,7 @@ function markdownCell(value) {
     .replaceAll("&", "&")
     .replaceAll("<", "&lt;")
     .replaceAll(">", "&gt;")
-    .replace(/\r?\n/g, "<br>");
+    .replace(/\r\n?|\n/g, " · ");
 }
 
 function localizedOperationalValue(value, pack, fallbackPack, fallbackLocale) {