@moreih29/nexus-core 0.9.0 → 0.11.0

package/manifest.json

@@ -1,6 +1,6 @@
 {
-  "nexus_core_version": "0.9.0",
-  "nexus_core_commit": "ff5fb5de66dc2bf5f45dfba141901ccca7eb48e9",
+  "nexus_core_version": "0.11.0",
+  "nexus_core_commit": "7d32c9e06ec206980cbc1399d29c8cb754cd0d5a",
   "schema_contract_version": "2.0",
   "agents": [
     {
@@ -35,6 +35,20 @@
       "id": "designer",
       "body_hash": "sha256:88ac56147d0e5bdf23fa591ce570a9c2d0eb1338df4ec2219f6238ddfcb65df4"
     },
+    {
+      "name": "engineer",
+      "description": "Implementation — writes code, debugs issues, follows specifications from Lead and architect",
+      "task": "Code implementation, edits, debugging",
+      "alias_ko": "엔지니어",
+      "category": "do",
+      "resume_tier": "bounded",
+      "model_tier": "standard",
+      "capabilities": [
+        "no_task_create"
+      ],
+      "id": "engineer",
+      "body_hash": "sha256:3d58b1b490c2f93cace2eedd0f04ec000f84514388eb086768cf53f8fa33db01"
+    },
     {
       "name": "reviewer",
       "description": "Content verification — validates accuracy, checks facts, confirms grammar and format of non-code deliverables",
@@ -50,20 +64,6 @@
       "id": "reviewer",
       "body_hash": "sha256:f04d15249601b14046e7e40a4475defb289436c4474afbd89986964f8c3e7c2f"
     },
-    {
-      "name": "engineer",
-      "description": "Implementation — writes code, debugs issues, follows specifications from Lead and architect",
-      "task": "Code implementation, edits, debugging",
-      "alias_ko": "엔지니어",
-      "category": "do",
-      "resume_tier": "bounded",
-      "model_tier": "standard",
-      "capabilities": [
-        "no_task_create"
-      ],
-      "id": "engineer",
-      "body_hash": "sha256:3d58b1b490c2f93cace2eedd0f04ec000f84514388eb086768cf53f8fa33db01"
-    },
     {
       "name": "strategist",
       "description": "Business strategy — evaluates market positioning, competitive landscape, and business viability of decisions",
@@ -142,19 +142,6 @@
     }
   ],
   "skills": [
-    {
-      "name": "nx-run",
-      "description": "Execution — user-directed agent composition.",
-      "summary": "Execution — user-directed agent composition",
-      "triggers": [
-        "run"
-      ],
-      "harness_docs_refs": [
-        "resume_invocation"
-      ],
-      "id": "nx-run",
-      "body_hash": "sha256:0e2c443efceeab4621709a85cd4e2ba50471d2e850680c655d776cbb62814549"
-    },
     {
       "name": "nx-init",
       "description": "Project onboarding — scan, mission, essentials, context generation",
@@ -188,7 +175,21 @@
         "resume_invocation"
       ],
       "id": "nx-plan",
-      "body_hash": "sha256:cd7a5fd1815530be6ffad18358a1295d1f74ef8a24132e75b73522c106eb6ae5"
+      "body_hash": "sha256:083ce49c06f8d3e4a0299aa8eb8e33460b68d6a277fe356b4db9635c21016aff"
+    },
+    {
+      "name": "nx-run",
+      "description": "Execution — user-directed agent composition.",
+      "summary": "Execution — user-directed agent composition",
+      "triggers": [
+        "run"
+      ],
+      "harness_docs_refs": [
+        "resume_invocation",
+        "nexus_hook_mapping"
+      ],
+      "id": "nx-run",
+      "body_hash": "sha256:0e2c443efceeab4621709a85cd4e2ba50471d2e850680c655d776cbb62814549"
     }
   ],
   "vocabulary": {
@@ -302,14 +303,16 @@
         "trigger": "[m]",
         "type": "inline_action",
         "handler": "memory_store",
-        "description": "Stores a lesson or reference to .nexus/memory/"
+        "description": "Stores a lesson or reference to .nexus/memory/",
+        "prose_guidance": "저장 admission 기준 — 코드/웹에서 다시 얻을 수 없는 정보만 저장한다. memory 파일의 naming, category, lifecycle 운영 정책은 vocabulary/memory_policy.yml과 docs/memory-lifecycle-contract.md를 canonical source로 참조한다.\n"
       },
       {
         "id": "m-gc",
         "trigger": "[m:gc]",
         "type": "inline_action",
         "handler": "memory_gc",
-        "description": "Garbage-collects .nexus/memory/ by merging or removing stale entries"
+        "description": "Garbage-collects .nexus/memory/ by merging or removing stale entries",
+        "prose_guidance": "gc 트리거 조건 평가, merge 판단, forgetting policy 집행은 vocabulary/memory_policy.yml에 정의된 원칙을 따르고 구체 임계값은 consumer-local 설정으로 결정한다.\n"
       },
       {
         "id": "rule",
@@ -346,7 +349,101 @@
         "description": "Ask the user a structured question with selectable options.",
         "intent": "structured_user_prompt",
         "fallback_behavior": "If the harness lacks a structured question tool (e.g., opencode-nexus),\npresent the question as prose followed by the options enumerated as a\nnumbered list, then await the user's free-form reply. The LLM is\nexpected to map the reply to the most appropriate option or treat it\nas a free-form answer if no options were given.\n"
+      },
+      {
+        "id": "memory_read_observation",
+        "description": "Harness-local observation of an agent reading a file under .nexus/memory/. This invocation captures the moment a memory file's content is loaded into an agent's context. It is not the read action itself — the read is performed by the harness's file-read primitive — but the observation event emitted by the harness after the read completes.\n",
+        "intent": "memory_read_observation",
+        "fallback_behavior": "If the harness cannot observe file-read events (no equivalent hook), memory access tracking is unavailable and forgetting decisions must rely on manual inspection via the [m:gc] tag. Automatic deletion policies requiring access metadata are consequently not enabled in such harnesses.\n"
+      }
+    ],
+    "task_exceptions": [
+      {
+        "id": "docs_only.coherent",
+        "description": "A batch of documentation files that all address the same scheme, decision, or structural change and should be treated as a single coherent unit.",
+        "applies_when": "all changed files are .md or frontmatter-only, and share one common scheme, decision, or structural change",
+        "treatment": "bundle into 1 writer task + 1 reviewer pair; file count / line count thresholds waived; state coherence claim in task approach field",
+        "rationale": "e.g., updating agent frontmatter files after a new field is introduced; files share the same change intent"
+      },
+      {
+        "id": "docs_only.independent",
+        "description": "A set of documentation files where each file addresses a distinct topic with no cross-reference dependency.",
+        "applies_when": "each .md file addresses a distinct topic with no cross-reference dependency",
+        "treatment": "N parallel writer tasks (one per file), each paired with 1 reviewer task; file count threshold waived per-task",
+        "rationale": "e.g., separate proposal drafts; each file is independently consumed"
+      },
+      {
+        "id": "same_file_bundle",
+        "description": "Two or more decomposed sub-tasks that would each modify the same target file, requiring merger to avoid conflicts.",
+        "applies_when": "two or more sub-tasks in the decomposition would each modify the same target file",
+        "treatment": "merge sub-tasks into a single task under one owner with a structured prompt listing each sub-task's requirements; the merged task counts as 1 task and 1 artifact cluster; does not apply when sub-tasks are sequenced (A's output feeds B) — those remain separate with a deps relationship",
+        "rationale": "parallel subagents targeting the same file cause merge conflicts"
+      },
+      {
+        "id": "generated_artifacts",
+        "description": "Files that are build output and do not represent independent authoring decisions.",
+        "applies_when": "files are build output (e.g., paths declared as build outputs in the harness's build configuration)",
+        "treatment": "excluded from task count, artifact cluster file count, and line count calculations; committed as part of the task that triggers their generation",
+        "rationale": "generated files do not represent independent authoring decisions"
       }
-    ]
+    ],
+    "memory_policy": {
+      "categories": [
+        {
+          "id": "empirical",
+          "prefix": "empirical-",
+          "description": "Empirically verified findings — observations and measurements that the project has confirmed through its own experimentation. Examples include runtime behavior observations, testing-derived structural facts, and operational measurements that cannot be inferred from documentation alone.\n"
+        },
+        {
+          "id": "external",
+          "prefix": "external-",
+          "description": "External constraints and references — requirements imposed by upstream dependencies, third-party API limits, vendor documentation quotations, and any knowledge that originates outside the project. May become stale if the upstream source changes.\n"
+        },
+        {
+          "id": "pattern",
+          "prefix": "pattern-",
+          "description": "Tactical operational patterns — recurring cycle-level recipes, routing heuristics, and procedural knowledge developed through work on the project. Architectural or design-level patterns belong in .nexus/context/, not here.\n"
+        }
+      ],
+      "naming": {
+        "pattern": "^[a-z0-9][a-z0-9-]*\\.md$",
+        "description": "Memory filenames are lowercase kebab-case .md files. The name should be a descriptive topic of 2–4 words. An optional category prefix from the categories section above may precede the topic. Version numbers and dates must not appear in filenames — temporal information belongs inside the file.\n",
+        "optional_prefix": true
+      },
+      "access_tracking": {
+        "observation_primitive": "file_read",
+        "scope": ".nexus/memory/",
+        "description": "Harnesses observe the moment an agent reads a memory file. Save events, directory scans (glob, grep), and mentions of the path in prose are not observation events. The set of events observed determines the accumulated access record.\n",
+        "information_accumulated": [
+          {
+            "name": "last_access_timestamp",
+            "meaning": "Wall-clock time of the most recent read event. Field name is harness-local; the canonical schema for storage is conformance/state-schemas/memory-access.schema.json.\n"
+          },
+          {
+            "name": "access_count",
+            "meaning": "Cumulative count of read events observed for this file since tracking began.\n"
+          },
+          {
+            "name": "last_reader_identity",
+            "meaning": "Identifier of the most recent reader (agent id or equivalent). Harness-local value domain.\n"
+          }
+        ],
+        "storage_contract_reference": "conformance/state-schemas/memory-access.schema.json"
+      },
+      "forgetting": {
+        "manual_gate_default": true,
+        "description": "Manual gc (triggered by the [m:gc] tag) is the default forgetting path. Automatic deletion is opt-in per consumer and never runs without explicit enablement.\n",
+        "automatic_deletion_structure": {
+          "principle": "minimum_three_signal_intersection",
+          "description": "If a consumer enables automatic deletion, the policy must require the simultaneous satisfaction of at least three independent signals — for example, elapsed time since last access, cycles since last read, and cumulative access count. Single-signal automatic deletion is prohibited. The specific signal thresholds are consumer-local and must be set to match the project's cycle cadence.\n"
+        },
+        "recoverable_deletion_requirement": "git_commit",
+        "recoverable_deletion_description": "Every memory file deletion must be recorded as a git commit. The commit message should include a recovery path that allows the file to be reconstructed via git history. Specific commit message format is consumer-local.\n"
+      },
+      "merge": {
+        "principle": "merge_before_create",
+        "description": "When a new memory save candidate substantively overlaps an existing file in topic and category, merging the new content into the existing file is preferred over creating a new file. Specific overlap-detection criteria (for example, keyword match thresholds) are consumer-local.\n"
+      }
+    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moreih29/nexus-core",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Nexus ecosystem Authoring layer — canonical prompts, neutral metadata, and vocabulary shared by Nexus harnesses",
   "license": "MIT",
   "repository": {

package/schema/manifest.schema.json

@@ -63,13 +63,15 @@
     "vocabulary": {
       "type": "object",
       "additionalProperties": false,
-      "required": ["capabilities", "categories", "resume_tiers", "tags", "invocations"],
+      "required": ["capabilities", "categories", "resume_tiers", "tags", "invocations", "task_exceptions", "memory_policy"],
       "properties": {
         "capabilities": { "type": "array" },
         "categories": { "type": "array" },
         "resume_tiers": { "type": "array" },
         "tags": { "type": "array" },
-        "invocations": { "type": "array" }
+        "invocations": { "type": "array" },
+        "task_exceptions": { "type": "array" },
+        "memory_policy": { "type": "object" }
       }
     }
   }

package/schema/memory-policy.schema.json

@@ -0,0 +1,98 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://moreih29/nexus-core/schema/memory-policy.schema.json",
+  "title": "Nexus Memory Policy",
+  "description": "Schema for vocabulary/memory_policy.yml — canonical memory policy for .nexus/memory/.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["categories", "naming", "access_tracking", "forgetting", "merge"],
+  "properties": {
+    "categories": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["id", "prefix", "description"],
+        "properties": {
+          "id": { "type": "string", "minLength": 1 },
+          "prefix": { "type": "string", "minLength": 1 },
+          "description": { "type": "string", "minLength": 1 }
+        }
+      }
+    },
+    "naming": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["pattern", "description", "optional_prefix"],
+      "properties": {
+        "pattern": { "type": "string", "minLength": 1 },
+        "description": { "type": "string", "minLength": 1 },
+        "optional_prefix": { "type": "boolean" }
+      }
+    },
+    "access_tracking": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "observation_primitive",
+        "scope",
+        "description",
+        "information_accumulated",
+        "storage_contract_reference"
+      ],
+      "properties": {
+        "observation_primitive": { "type": "string", "minLength": 1 },
+        "scope": { "type": "string", "minLength": 1 },
+        "description": { "type": "string", "minLength": 1 },
+        "information_accumulated": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["name", "meaning"],
+            "properties": {
+              "name": { "type": "string", "minLength": 1 },
+              "meaning": { "type": "string", "minLength": 1 }
+            }
+          }
+        },
+        "storage_contract_reference": { "type": "string", "minLength": 1 }
+      }
+    },
+    "forgetting": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "manual_gate_default",
+        "description",
+        "automatic_deletion_structure",
+        "recoverable_deletion_requirement",
+        "recoverable_deletion_description"
+      ],
+      "properties": {
+        "manual_gate_default": { "type": "boolean" },
+        "description": { "type": "string", "minLength": 1 },
+        "automatic_deletion_structure": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["principle", "description"],
+          "properties": {
+            "principle": { "type": "string", "minLength": 1 },
+            "description": { "type": "string", "minLength": 1 }
+          }
+        },
+        "recoverable_deletion_requirement": { "type": "string", "minLength": 1 },
+        "recoverable_deletion_description": { "type": "string", "minLength": 1 }
+      }
+    },
+    "merge": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["principle", "description"],
+      "properties": {
+        "principle": { "type": "string", "minLength": 1 },
+        "description": { "type": "string", "minLength": 1 }
+      }
+    }
+  }
+}

package/schema/task-exceptions.schema.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://moreih29/nexus-core/schema/task-exceptions.schema.json",
+  "title": "Nexus Task Exceptions vocabulary file",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["task_exceptions"],
+  "properties": {
+    "task_exceptions": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["id", "description", "applies_when", "treatment", "rationale"],
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^[a-z][a-z0-9_]*(\\.[a-z][a-z0-9_]*)?$"
+          },
+          "description": {
+            "type": "string",
+            "minLength": 1
+          },
+          "applies_when": {
+            "type": "string",
+            "minLength": 1
+          },
+          "treatment": {
+            "type": "string",
+            "minLength": 1
+          },
+          "rationale": {
+            "type": "string",
+            "minLength": 1
+          }
+        }
+      }
+    }
+  }
+}

package/schema/vocabulary.schema.json

@@ -70,7 +70,8 @@
         "description": { "$ref": "common.schema.json#/$defs/description" },
         "skill": { "$ref": "common.schema.json#/$defs/id" },
         "handler": { "type": "string", "minLength": 1 },
-        "variants": { "type": "array", "items": { "type": "string", "minLength": 1 } }
+        "variants": { "type": "array", "items": { "type": "string", "minLength": 1 } },
+        "prose_guidance": { "type": "string", "minLength": 40 }
       },
       "if": {
         "properties": { "type": { "const": "skill" } },
@@ -137,6 +138,30 @@
       "properties": {
         "invocations": { "type": "array", "items": { "$ref": "#/$defs/invocationEntry" } }
       }
-    }
+    },
+    "taskExceptionEntry": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "description", "applies_when", "treatment", "rationale"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "pattern": "^[a-z][a-z0-9_]*(\\.[a-z][a-z0-9_]*)?$"
+        },
+        "description": { "type": "string", "minLength": 1 },
+        "applies_when": { "type": "string", "minLength": 1 },
+        "treatment": { "type": "string", "minLength": 1 },
+        "rationale": { "type": "string", "minLength": 1 }
+      }
+    },
+    "taskExceptionFile": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["task_exceptions"],
+      "properties": {
+        "task_exceptions": { "type": "array", "items": { "$ref": "#/$defs/taskExceptionEntry" } }
+      }
+    },
+    "memoryPolicyFile": { "$ref": "memory-policy.schema.json" }
   }
 }

package/scripts/lib/validate.ts

@@ -81,12 +81,30 @@ interface InvocationEntry {
   fallback_behavior: string;
 }
 
+interface TaskExceptionEntry {
+  id: string;
+  description: string;
+  applies_when: string;
+  treatment: string;
+  rationale: string;
+}
+
+interface MemoryPolicy {
+  categories: unknown[];
+  naming: unknown;
+  access_tracking: unknown;
+  forgetting: unknown;
+  merge: unknown;
+}
+
 interface Vocab {
   capabilities: CapabilityEntry[];
   categories: SimpleEntry[];
   resume_tiers: SimpleEntry[];
   tags: TagEntry[];
   invocations: InvocationEntry[];
+  task_exceptions: TaskExceptionEntry[];
+  memory_policy: MemoryPolicy;
 }
 
 interface ManifestAgent extends AgentMeta {
@@ -116,6 +134,8 @@ interface Manifest {
     resume_tiers: SimpleEntry[];
     tags: TagEntry[];
     invocations: ManifestInvocationEntry[];
+    task_exceptions: TaskExceptionEntry[];
+    memory_policy: MemoryPolicy;
   };
 }
 
@@ -129,6 +149,8 @@ interface LoadedSchemas {
   skillValidator: ValidateFunction;
   vocabValidator: ValidateFunction;
   manifestValidator: ValidateFunction;
+  taskExceptionValidator: ValidateFunction;
+  memoryPolicyValidator: ValidateFunction;
 }
 
 let cachedSchemas: LoadedSchemas | null = null;
@@ -152,12 +174,14 @@ export async function loadSchemas(root: string): Promise<void> {
   addFormats(ajv);
   ajvErrors(ajv);
 
-  const [commonRaw, agentRaw, skillRaw, vocabRaw, manifestRaw] = await Promise.all([
+  const [commonRaw, agentRaw, skillRaw, vocabRaw, manifestRaw, taskExceptionSchemaRaw, memoryPolicySchemaRaw] = await Promise.all([
     readFile(path.join(schemaDir, 'common.schema.json'), 'utf8'),
     readFile(path.join(schemaDir, 'agent.schema.json'), 'utf8'),
     readFile(path.join(schemaDir, 'skill.schema.json'), 'utf8'),
     readFile(path.join(schemaDir, 'vocabulary.schema.json'), 'utf8'),
     readFile(path.join(schemaDir, 'manifest.schema.json'), 'utf8'),
+    readFile(path.join(schemaDir, 'task-exceptions.schema.json'), 'utf8'),
+    readFile(path.join(schemaDir, 'memory-policy.schema.json'), 'utf8'),
   ]);
 
   const commonSchema = JSON.parse(commonRaw) as Record<string, unknown>;
@@ -165,6 +189,8 @@ export async function loadSchemas(root: string): Promise<void> {
   const skillSchema = JSON.parse(skillRaw) as Record<string, unknown>;
   const vocabSchema = JSON.parse(vocabRaw) as Record<string, unknown>;
   const manifestSchema = JSON.parse(manifestRaw) as Record<string, unknown>;
+  const taskExceptionSchema = JSON.parse(taskExceptionSchemaRaw) as Record<string, unknown>;
+  const memoryPolicySchema = JSON.parse(memoryPolicySchemaRaw) as Record<string, unknown>;
 
   ajv.addSchema(commonSchema);
   ajv.addSchema(vocabSchema);
@@ -210,6 +236,8 @@ export async function loadSchemas(root: string): Promise<void> {
   const resumeTierValidator = await ajv.compileAsync(resumeTierFileSchema);
   const tagValidator = await ajv.compileAsync(tagFileSchema);
   const invocationValidator = await ajv.compileAsync(invocationFileSchema);
+  const taskExceptionValidator = await ajv.compileAsync(taskExceptionSchema);
+  const memoryPolicyValidator = await ajv.compileAsync(memoryPolicySchema);
 
   const manifestAjv = new Ajv2020({
     strict: false,
@@ -233,10 +261,12 @@ export async function loadSchemas(root: string): Promise<void> {
     // Store vocabulary validators and manifest as composite
     vocabValidator: capabilityValidator, // placeholder — we handle vocab separately below
     manifestValidator,
+    taskExceptionValidator,
+    memoryPolicyValidator,
   };
 
   // Store all vocab validators for internal use
-  _vocabValidators = { capabilityValidator, categoryValidator, resumeTierValidator, tagValidator, invocationValidator };
+  _vocabValidators = { capabilityValidator, categoryValidator, resumeTierValidator, tagValidator, invocationValidator, taskExceptionValidator, memoryPolicyValidator };
 }
 
 interface VocabValidators {
@@ -245,6 +275,8 @@ interface VocabValidators {
   resumeTierValidator: ValidateFunction;
   tagValidator: ValidateFunction;
   invocationValidator: ValidateFunction;
+  taskExceptionValidator: ValidateFunction;
+  memoryPolicyValidator: ValidateFunction;
 }
 
 let _vocabValidators: VocabValidators | null = null;
@@ -559,15 +591,17 @@ async function loadVocab(root: string): Promise<{ vocab: Vocab | null; results:
     return data as T;
   }
 
-  const [capData, catData, resumeData, tagData, invocationData] = await Promise.all([
+  const [capData, catData, resumeData, tagData, invocationData, taskExceptionData, memoryPolicyData] = await Promise.all([
     loadYaml<{ capabilities: CapabilityEntry[] }>('capabilities.yml', _vocabValidators.capabilityValidator),
     loadYaml<{ categories: SimpleEntry[] }>('categories.yml', _vocabValidators.categoryValidator),
     loadYaml<{ resume_tiers: SimpleEntry[] }>('resume-tiers.yml', _vocabValidators.resumeTierValidator),
     loadYaml<{ tags: TagEntry[] }>('tags.yml', _vocabValidators.tagValidator),
     loadYaml<{ invocations: InvocationEntry[] }>('invocations.yml', _vocabValidators.invocationValidator),
+    loadYaml<{ task_exceptions: TaskExceptionEntry[] }>('task-exceptions.yml', _vocabValidators.taskExceptionValidator),
+    loadYaml<MemoryPolicy>('memory_policy.yml', _vocabValidators.memoryPolicyValidator),
   ]);
 
-  if (!capData || !catData || !resumeData || !tagData || !invocationData) {
+  if (!capData || !catData || !resumeData || !tagData || !invocationData || !taskExceptionData || !memoryPolicyData) {
     return { vocab: null, results };
   }
 
@@ -578,6 +612,8 @@ async function loadVocab(root: string): Promise<{ vocab: Vocab | null; results:
       resume_tiers: resumeData.resume_tiers,
       tags: tagData.tags,
       invocations: invocationData.invocations,
+      task_exceptions: taskExceptionData.task_exceptions,
+      memory_policy: memoryPolicyData,
     },
     results,
   };
@@ -636,6 +672,8 @@ export async function generateManifest(
       resume_tiers: vocab.resume_tiers,
       tags: vocab.tags,
       invocations: invocationSummaries,
+      task_exceptions: vocab.task_exceptions,
+      memory_policy: vocab.memory_policy,
     },
   };
 }

package/skills/nx-plan/body.md

@@ -220,12 +220,21 @@ All issues decided → generate the plan document (tasks.json) immediately:
    | Design analysis / review | **architect** etc. HOW | Technical trade-off judgment |
    | Sequential edits to same file | **lead** | Parallel subagents risk conflict |
 
-   **Verification auto-pairing** — create separate verification tasks:
-   - Any task with `owner: "engineer"` + `acceptance` field → pair a **tester** task (verify acceptance criteria)
-   - Any task with `owner: "writer"` → pair a **reviewer** task (verify deliverable)
-   - Paired verification tasks are linked via `deps` to the original task
+   **Primary metric — artifact-coherence**: a well-scoped task targets a single artifact or a tightly coupled artifact cluster and makes a single coherent change. A change is coherent when (a) it can be described in one sentence, (b) reverting it leaves all other artifacts consistent, and (c) its acceptance can be verified by inspecting its outputs alone.
 
-   **DO/CHECK decomposition principle**: DO category agents (engineer, writer, researcher) and CHECK category agents (tester, reviewer) operate on artifact-level scope and accumulate less per-task context than HOW category agents. When a task involves multiple independent artifacts (several files, several verification targets, multiple research questions), decompose the task across multiple parallel DO/CHECK subagents rather than bundling them into a single subagent. Single-subagent bundles risk context exhaustion with no wall-clock benefit over parallel decomposition. HOW agents benefit from consolidated context and should generally remain as single sessions. Task granularity is assessed per-task by the plan author, not declared per-agent in meta.yml.
+   **Verification auto-pairing (conditional)** — create a CHECK task only when the DO task's acceptance includes the appropriate verification trigger:
+   - `owner: "engineer"` + acceptance contains a runtime-behavior criterion → pair a **tester** task.
+   - `owner: "writer"` + acceptance contains a verifiable deliverable criterion → pair a **reviewer** task.
+   - Exclusions: pure refactor (behavior-preserving), type-only changes, docs-adjacent tasks (.md or frontmatter-only, classified under `docs_only` entries in `vocabulary/task-exceptions.yml`), and researcher tasks. Researcher tasks never receive an auto-paired CHECK — research outputs feed Lead or HOW agents directly, not tester or reviewer.
+   - Paired verification tasks are linked via `deps` to the original task.
+
+   **Exception catalog**: task decomposition exceptions are defined in `vocabulary/task-exceptions.yml` (`docs_only.coherent`, `docs_only.independent`, `same_file_bundle`, `generated_artifacts`). When an exception applies to a task, record its id in the task's `context` field so downstream tooling can trace the classification.
+
+   **Dedup Layer 1 (plan-time static merge)**: before finalizing the task list, scan draft tasks for overlapping target_files. Overlapping tasks are merged into a single owner task via the `same_file_bundle` exception from `vocabulary/task-exceptions.yml` to prevent parallel write conflicts during execution.
+
+   **DO/CHECK decomposition principle**: DO agents (engineer, writer, researcher) and CHECK agents (tester, reviewer) accumulate less per-task context than HOW agents. When a task involves multiple independent artifacts, decompose across multiple parallel DO/CHECK subagents rather than bundling. HOW agents benefit from consolidated context and should generally remain as single sessions. Parallel decomposition is worthwhile when there are at least three independent artifacts; below that, bundling under one owner is preferable to avoid parallelization overhead.
+
+   **HOW decomposition rule**: split HOW analysis across multiple subagents only when the issue crosses different rows of the domain-agent mapping table (architect vs designer vs strategist vs postdoc). Sub-concerns within a single domain row belong in one HOW session.
 
 4. **Populate tasks.json** via `nx_task_add`:
    - Set `goal` from the plan topic

package/skills/nx-run/meta.yml

@@ -5,4 +5,5 @@ triggers:
   - run
 harness_docs_refs:
   - resume_invocation
+  - nexus_hook_mapping
 id: nx-run

package/vocabulary/invocations.yml

@@ -114,3 +114,34 @@ invocations:
       numbered list, then await the user's free-form reply. The LLM is
       expected to map the reply to the most appropriate option or treat it
       as a free-form answer if no options were given.
+
+  - id: memory_read_observation
+    description: >
+      Harness-local observation of an agent reading a file under .nexus/memory/.
+      This invocation captures the moment a memory file's content is loaded into
+      an agent's context. It is not the read action itself — the read is performed
+      by the harness's file-read primitive — but the observation event emitted by
+      the harness after the read completes.
+    intent: memory_read_observation
+    semantic_params:
+      - name: file_path
+        description: Absolute or project-relative path to the memory file that was read.
+        required: true
+      - name: reader_identity
+        description: Opaque identifier of the agent or subject that performed the read.
+        required: true
+      - name: observed_at
+        description: ISO 8601 timestamp of the observation event.
+        required: true
+    prose_guidance: >
+      Harnesses that wish to track memory access to support informed gc decisions
+      should implement this observation by hooking into their filesystem read
+      primitive and emitting the event after a read under .nexus/memory/ completes.
+      Writes and directory scans are excluded. The accumulated records are persisted
+      per conformance/state-schemas/memory-access.schema.json at
+      .nexus/state/{harness_id}/memory-access.jsonl.
+    fallback_behavior: >
+      If the harness cannot observe file-read events (no equivalent hook), memory
+      access tracking is unavailable and forgetting decisions must rely on manual
+      inspection via the [m:gc] tag. Automatic deletion policies requiring access
+      metadata are consequently not enabled in such harnesses.