nativesoul 0.1.0

package/plugins/codex-nativesoul/.codex-plugin/plugin.json

@@ -0,0 +1,83 @@
+{
+  "name": "codex-nativesoul",
+  "version": "0.1.0",
+  "description": "NativeSoul continuity bootstrap for Codex sessions.",
+  "author": {
+    "name": "NativeSoul",
+    "email": "noreply@example.com"
+  },
+  "license": "MIT",
+  "keywords": ["nativesoul", "continuity", "bootstrap", "codex"],
+  "skills": "./skills/",
+  "mcpServers": "./.mcp.json",
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node hooks/session-start.cjs",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node hooks/memory-flush.cjs",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node hooks/memory-flush.cjs",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node hooks/user-prompt-submit.cjs",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node hooks/pre-tool-use.cjs",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  },
+  "interface": {
+    "displayName": "NativeSoul",
+    "shortDescription": "Local continuity bootstrap for Codex sessions.",
+    "longDescription": "Loads NativeSoul identity, operating context, project memory, and fallback cache at Codex session start.",
+    "developerName": "NativeSoul",
+    "category": "Productivity",
+    "capabilities": ["Local", "Context"],
+    "defaultPrompt": [
+      "Start this Codex session with NativeSoul context.",
+      "Recall my NativeSoul project memory.",
+      "Check NativeSoul bootstrap status."
+    ]
+  }
+}

package/plugins/codex-nativesoul/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "nativesoul": {
+      "command": "nativesoul-mcp",
+      "args": []
+    }
+  }
+}

package/plugins/codex-nativesoul/hooks/loader.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+const path = require('node:path');
+const fs = require('node:fs');
+
+function sharedRoots(fromDir) {
+  return [
+    path.join(fromDir, '..', 'shared', 'hooks'),
+    path.join(fromDir, '..', '..', 'shared', 'hooks')
+  ];
+}
+
+function loadShared(fromDir, name) {
+  for (const root of sharedRoots(fromDir)) {
+    const candidate = path.join(root, name);
+    if (fs.existsSync(candidate)) {
+      return require(candidate);
+    }
+  }
+  throw new Error(`NativeSoul shared hook module not found: ${name}`);
+}
+
+module.exports = { loadShared, sharedRoots };

package/plugins/codex-nativesoul/hooks/memory-flush.cjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+'use strict';
+
+const { loadShared } = require('./loader.cjs');
+const lib = loadShared(__dirname, 'lib.cjs');
+
+const HOOK_TIMEOUT_MS = lib.DEFAULT_HOOK_TIMEOUT_MS;
+const HOST = 'codex';
+const PROJECT_ENV = 'CODEX_PROJECT_DIR';
+
+function flushArgs(input) {
+  const cwd = lib.resolveProjectDir(input, PROJECT_ENV);
+  const event = input.hook_event_name || input.event || 'Stop';
+  return lib.appendHomeArg(['memory', 'flush-hook', '--host', HOST, '--cwd', cwd, '--event', event, '--json']);
+}
+
+function runNativeSoul(input) {
+  return lib.spawnNativeSoul(flushArgs(input), {
+    input: `${JSON.stringify(input)}\n`,
+    timeout: HOOK_TIMEOUT_MS
+  });
+}
+
+async function main() {
+  const input = await lib.readStdin();
+  runNativeSoul(input);
+}
+
+function run() {
+  lib.runNonBlocking(main, HOOK_TIMEOUT_MS);
+}
+
+if (require.main === module) {
+  run();
+}
+
+module.exports = {
+  HOOK_TIMEOUT_MS,
+  HOST,
+  flushArgs,
+  readStdin: lib.readStdin,
+  runNativeSoul,
+  main,
+  run
+};

package/plugins/codex-nativesoul/hooks/pre-tool-use.cjs

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+'use strict';
+
+const { loadShared } = require('./loader.cjs');
+const lib = loadShared(__dirname, 'lib.cjs');
+const policy = loadShared(__dirname, 'policy-fail-closed.cjs');
+
+const HOOK_TIMEOUT_MS = lib.DEFAULT_HOOK_TIMEOUT_MS;
+const HOST = 'codex';
+const PROJECT_ENV = 'CODEX_PROJECT_DIR';
+
+function policyArgs(input) {
+  const cwd = lib.resolveProjectDir(input, PROJECT_ENV);
+  return lib.appendHomeArg(['policy', 'pretooluse-hook', '--host', HOST, '--cwd', cwd, '--json']);
+}
+
+function runNativeSoul(input) {
+  const result = lib.spawnNativeSoul(policyArgs(input), {
+    input: `${JSON.stringify(input)}\n`,
+    timeout: HOOK_TIMEOUT_MS
+  });
+  const parsed = lib.parseJsonStdout(result);
+  return parsed ?? policy.buildFailClosedPreToolUseResult(input);
+}
+
+async function main() {
+  const input = await lib.readStdin({ fallback: (raw) => ({ raw }) });
+  const result = runNativeSoul(input);
+  const output = lib.buildPreToolUseHookOutput(result);
+  if (output) {
+    process.stdout.write(`${JSON.stringify(output)}\n`);
+  }
+}
+
+function run() {
+  lib.runNonBlocking(main, HOOK_TIMEOUT_MS);
+}
+
+if (require.main === module) {
+  run();
+}
+
+module.exports = {
+  HOOK_TIMEOUT_MS,
+  HOST,
+  buildHookOutput: lib.buildPreToolUseHookOutput,
+  fallbackPolicyResult: policy.buildFailClosedPreToolUseResult,
+  policyArgs,
+  readStdin: lib.readStdin,
+  runNativeSoul,
+  main,
+  run
+};

package/plugins/codex-nativesoul/hooks/session-start.cjs

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+'use strict';
+
+const { loadShared } = require('./loader.cjs');
+const lib = loadShared(__dirname, 'lib.cjs');
+
+const HOOK_TIMEOUT_MS = lib.DEFAULT_HOOK_TIMEOUT_MS;
+const HOST = 'codex';
+const PROJECT_ENV = 'CODEX_PROJECT_DIR';
+
+function bootstrapArgs(input, format) {
+  const cwd = lib.resolveProjectDir(input, PROJECT_ENV);
+  return lib.appendHomeArg(['bootstrap', '--host', HOST, '--cwd', cwd, '--format', format, '--json']);
+}
+
+function capabilityRefreshArgs() {
+  const args = ['capabilities', 'refresh', '--host', HOST, '--delta', '--json'];
+  lib.appendHomeArg(args);
+  const ttl = process.env.NATIVESOUL_CAPABILITY_REFRESH_TTL_SECONDS;
+  if (ttl && ttl.trim().length > 0) {
+    args.push('--ttl-seconds', ttl.trim());
+  }
+  return args;
+}
+
+function runCapabilityRefresh() {
+  const result = lib.spawnNativeSoul(capabilityRefreshArgs(), {
+    timeout: 1900,
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+  if (result.status !== 0) {
+    return { stale: true };
+  }
+  try {
+    const parsed = JSON.parse(result.stdout);
+    const stale = Array.isArray(parsed) && parsed.some((item) => item && item.status === 'degraded');
+    const skipped = Array.isArray(parsed) && parsed.every((item) => item && item.skipped === true);
+    return { stale, skipped };
+  } catch {
+    return { stale: true };
+  }
+}
+
+function runCapabilityLearn() {
+  lib.spawnNativeSoul(lib.appendHomeArg(['capabilities', 'learn', '--host', HOST, '--json']), {
+    timeout: 1900,
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+}
+
+function runNativeSoul(input, format) {
+  const result = lib.spawnNativeSoul(bootstrapArgs(input, format), {
+    timeout: HOOK_TIMEOUT_MS,
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+  return lib.parseJsonStdout(result);
+}
+
+function writeProjectFallbackCache(input, context) {
+  const cwd = lib.resolveProjectDir(input, PROJECT_ENV);
+  return lib.writeProjectFallbackCache({ context, cwd, host: HOST });
+}
+
+function readProjectFallbackCache(input) {
+  const cwd = lib.resolveProjectDir(input, PROJECT_ENV);
+  return lib.readProjectFallbackCache({ cwd, host: HOST });
+}
+
+function buildHookOutput(context) {
+  const outputContext = context.capabilityRefreshStale
+    ? `${context.content}\n\nwarnings:\n- CAPABILITY_REFRESH_STALE`
+    : context.content;
+  return {
+    context: outputContext,
+    degraded: context.degraded === true,
+    source: 'nativesoul'
+  };
+}
+
+async function main() {
+  const input = await lib.readStdin({ fallback: () => ({}) });
+  const capabilityRefresh = runCapabilityRefresh();
+  if (!capabilityRefresh.stale && !capabilityRefresh.skipped) {
+    runCapabilityLearn();
+  }
+  const injected = writeProjectFallbackCache(input, runNativeSoul(input, 'inject'));
+  const context = injected && typeof injected.content === 'string'
+    ? injected
+    : runNativeSoul(input, 'cache') || readProjectFallbackCache(input);
+
+  if (!context || typeof context.content !== 'string') {
+    return;
+  }
+
+  process.stdout.write(`${JSON.stringify(buildHookOutput({ ...context, capabilityRefreshStale: capabilityRefresh.stale }))}\n`);
+}
+
+function run() {
+  lib.runNonBlocking(main, HOOK_TIMEOUT_MS);
+}
+
+if (require.main === module) {
+  run();
+}
+
+module.exports = {
+  HOOK_TIMEOUT_MS,
+  bootstrapArgs,
+  capabilityRefreshArgs,
+  buildHookOutput,
+  readStdin: lib.readStdin,
+  runCapabilityRefresh,
+  runCapabilityLearn,
+  runNativeSoul,
+  writeProjectFallbackCache,
+  readProjectFallbackCache,
+  main,
+  run
+};

package/plugins/codex-nativesoul/hooks/user-prompt-submit.cjs

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+'use strict';
+
+const { loadShared } = require('./loader.cjs');
+const lib = loadShared(__dirname, 'lib.cjs');
+
+const HOOK_TIMEOUT_MS = lib.DEFAULT_HOOK_TIMEOUT_MS;
+const HOST = 'codex';
+const PROJECT_ENV = 'CODEX_PROJECT_DIR';
+
+function recallArgs(input) {
+  const cwd = lib.resolveProjectDir(input, PROJECT_ENV);
+  return lib.appendHomeArg(['memory', 'recall-hook', '--host', HOST, '--cwd', cwd, '--json']);
+}
+
+function runNativeSoul(input) {
+  const result = lib.spawnNativeSoul(recallArgs(input), {
+    input: `${JSON.stringify(input)}\n`,
+    timeout: HOOK_TIMEOUT_MS
+  });
+  return lib.parseJsonStdout(result);
+}
+
+function buildHookOutput(result) {
+  if (!result || typeof result.context !== 'string' || result.context.length === 0) {
+    return null;
+  }
+  return {
+    hookSpecificOutput: {
+      hookEventName: 'UserPromptSubmit',
+      additionalContext: result.context
+    }
+  };
+}
+
+async function main() {
+  const input = await lib.readStdin({ fallback: (raw) => ({ prompt: raw }) });
+  const result = runNativeSoul(input);
+  const output = buildHookOutput(result);
+  if (output) {
+    process.stdout.write(`${JSON.stringify(output)}\n`);
+  }
+}
+
+function run() {
+  lib.runNonBlocking(main, HOOK_TIMEOUT_MS);
+}
+
+if (require.main === module) {
+  run();
+}
+
+module.exports = {
+  HOOK_TIMEOUT_MS,
+  HOST,
+  buildHookOutput,
+  recallArgs,
+  readStdin: lib.readStdin,
+  runNativeSoul,
+  main,
+  run
+};

package/plugins/codex-nativesoul/skills/life-explore/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: life-explore
+description: Explore a project locally with NativeSoul context using bounded read-only discovery.
+---
+
+# life:explore
+
+Use this skill when the operator asks to explore a codebase, find current implementation boundaries, or map what exists.
+
+Default policy: read-only and bounded. Never edit files, run migrations, install packages, start background services, or trigger external writes from this skill.
+
+1. Load context with MCP `life_bootstrap` using `host="codex"` and the current working directory.
+2. Inspect capability readiness using `nativesoul dashboard data --host codex --limit 25 --json` or MCP capability tools.
+3. Scope exploration to the operator's request. Prefer targeted file discovery such as:
+
+```sh
+rg --files
+rg "<specific term from the task>"
+```
+
+4. Avoid broad unbounded scans. If the task is vague, inspect only high-signal files first: README, package metadata, docs, stories, ADRs, and nearby source modules.
+5. Report findings with file paths and distinguish verified code facts from memory-derived or inferred context.
+6. If a write, install, network call, scheduler mutation, or policy change seems needed, stop and ask for normal approval instead of performing it inside this skill.
+

package/plugins/codex-nativesoul/skills/life-heartbeat/SKILL.md

@@ -0,0 +1,21 @@
+---
+name: life-heartbeat
+description: Run NativeSoul heartbeat from a Codex Automation.
+---
+
+# life:heartbeat
+
+Use this skill only when invoked by a Codex Automation for NativeSoul heartbeat checks.
+
+Default policy: read-only. Do not edit workspace files, memories, `SOUL.md`, `POLICY.md`, automation state, or host configuration unless the operator explicitly approves a follow-up change.
+
+1. Determine the project from the Automation context. If it is missing, use the current working directory.
+2. Claim a local heartbeat lease through MCP `life_heartbeat_claim` with `host="codex"`, the project id or directory, and the Automation slot/time as `slot`.
+3. If another host owns the lease, the lease is already completed, or no work is needed, stop and return only `HEARTBEAT_OK`.
+4. Read NativeSoul context through MCP/read-only commands and inspect heartbeat guidance such as `HEARTBEAT.md`.
+5. If no operator-visible action is required, complete the lease with MCP `life_heartbeat_complete` and `result="HEARTBEAT_OK"`, then return only `HEARTBEAT_OK`.
+6. If action is required, complete the lease with concise evidence, then report the action request without secrets or raw credentials.
+
+`HEARTBEAT_OK` is a silent acknowledgement token. Do not notify the user for it.
+
+Never create a cron fallback. If Codex Automations are unavailable, the adapter must report unsupported and leave local schedule state as unsupported.

package/plugins/codex-nativesoul/skills/life-plan/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: life-plan
+description: Build a local NativeSoul execution plan from dashboard, commitments, schedules, and capability state.
+---
+
+# life:plan
+
+Use this skill when the operator asks for a NativeSoul-aware plan before execution.
+
+Default policy: read-only. Do not apply schedules, policy packs, onboarding changes, memory transitions, or workspace edits unless the operator explicitly approves the next action.
+
+1. Load context with MCP `life_bootstrap` using `host="codex"` and the current working directory.
+2. Read local dashboard state:
+
+```sh
+nativesoul dashboard data --host codex --limit 25 --json
+```
+
+3. Read open commitments if needed:
+
+```sh
+nativesoul commitments list --project <project-id> --status open --limit 25 --json
+```
+
+4. Read capability readiness with `nativesoul capabilities list --host codex --limit 25 --json`.
+5. Produce a plan that separates implemented state, degraded/fallback state, and approval-required actions.
+6. Do not claim a host feature is native unless the capability evidence says `full native capability`.
+

package/plugins/codex-nativesoul/skills/life-recall/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: life-recall
+description: Recall NativeSoul project memory and capability context for the current Codex task.
+---
+
+# life:recall
+
+Use this skill when the operator asks for prior context, project memory, or continuity before a Codex task.
+
+Default policy: read-only. Do not create, promote, reject, forget, or edit memories unless the operator explicitly asks for that policy flow.
+
+1. Determine the current working directory and concise task query.
+2. Prefer MCP `life_recall` with `host="codex"`, the current project/cwd, and the task query.
+3. If MCP is unavailable, run:
+
+```sh
+nativesoul memory recall-hook --host codex --cwd "$PWD" --prompt "<task query>" --limit 8 --json
+```
+
+4. If recall output is empty, say no durable memory was found; do not invent context.
+5. Treat recovered memory as advisory and verify against repository files before making code decisions.
+6. Include capability readiness honestly when relevant: `ready`, `full native capability`, `official-fallback`, or `degraded`.
+

package/plugins/codex-nativesoul/skills/life-start/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: life-start
+description: Load NativeSoul continuity context at the start of a Codex session.
+---
+
+# life:start
+
+Use this skill at the start of a Codex session when NativeSoul context is needed.
+
+1. Prefer the session hook context if it is already present.
+2. If context is missing, call MCP `life_bootstrap` with `host="codex"` and the current working directory.
+3. If MCP is unavailable, run:
+
+```sh
+nativesoul bootstrap --host codex --cwd "$PWD" --format cache
+```
+
+Follow the injected `soul_summary`, `agents_operating_summary`, policy hints, and project context. Do not edit `SOUL.md` or `POLICY.md` directly; propose changes for approval.

package/plugins/gemini-nativesoul/GEMINI.md

@@ -0,0 +1,17 @@
+<!-- nativesoul:start v1 -->
+# NativeSoul bridge for Gemini CLI
+
+At the start of continuity-sensitive work, load NativeSoul context.
+
+Preferred path: use MCP `life_bootstrap` with `host="gemini"` and the current working directory.
+
+Fallback path: run `nativesoul bootstrap --host gemini --cwd <current-working-directory> --format inject --json`.
+
+Use `/memory refresh` after installing or updating this extension so Gemini reloads this context.
+
+Use `relevant_memories` for durable facts, `capability_cards` as advisory guidance, and `capabilities` only as the ready-only list.
+
+Never copy credentials or auto-edit `SOUL.md`/`POLICY.md`; propose those changes for approval.
+
+Host adapter: gemini.
+<!-- nativesoul:end -->

package/plugins/gemini-nativesoul/commands/nativesoul-explore.toml

@@ -0,0 +1,3 @@
+description = "Explore a project locally with NativeSoul context using bounded read-only discovery."
+prompt = "Explore the current project in read-only mode. Load NativeSoul context with host=\"gemini\", inspect `nativesoul dashboard data --host gemini --limit 25 --json`, then use targeted local discovery such as `rg --files` and `rg <specific term>` scoped to the operator request. Avoid broad unbounded scans. Never edit files, install packages, start services, create schedulers, or perform external writes from this command; ask for normal approval if a write is needed."
+

package/plugins/gemini-nativesoul/commands/nativesoul-heartbeat.toml

@@ -0,0 +1,2 @@
+description = "Run an NativeSoul heartbeat tick through Gemini CLI without installing a hidden scheduler."
+prompt = "Run an NativeSoul heartbeat for this project using MCP life_heartbeat_claim with host=\"gemini\". If the claim returns HEARTBEAT_OK or no work is available, do not notify the user. Complete the lease with life_heartbeat_complete only if Gemini won the lease."

package/plugins/gemini-nativesoul/commands/nativesoul-plan.toml

@@ -0,0 +1,3 @@
+description = "Build a read-only NativeSoul execution plan from local dashboard and capability state."
+prompt = "Build a read-only plan using NativeSoul local state. Call MCP life_bootstrap with host=\"gemini\", then read `nativesoul dashboard data --host gemini --limit 25 --json`, open commitments when relevant, and `nativesoul capabilities list --host gemini --limit 25 --json`. Separate implemented state, degraded/fallback state, and approval-required actions. Do not mutate schedules, memory, policy, or files unless the operator explicitly approves a later action."
+

package/plugins/gemini-nativesoul/commands/nativesoul-recall.toml

@@ -0,0 +1,3 @@
+description = "Recall NativeSoul project memory and capability context for the current Gemini task."
+prompt = "Run a read-only NativeSoul recall for the current task. Prefer MCP life_recall with host=\"gemini\" and the current working directory. If MCP is unavailable, run `nativesoul memory recall-hook --host gemini --cwd <current-working-directory> --prompt <task query> --limit 8 --json`. Treat recovered memory as advisory, verify against files, and report capability readiness honestly as ready, full native capability, official-fallback, or degraded."
+

package/plugins/gemini-nativesoul/commands/nativesoul-start.toml

@@ -0,0 +1,2 @@
+description = "Load NativeSoul context for the current Gemini workspace."
+prompt = "Call MCP life_bootstrap with host=\"gemini\" and the current working directory. If MCP is unavailable, run `nativesoul bootstrap --host gemini --cwd <current-working-directory> --format inject --json` and follow the returned context."

package/plugins/gemini-nativesoul/gemini-extension.json

@@ -0,0 +1,16 @@
+{
+  "name": "nativesoul",
+  "version": "0.1.0",
+  "mcpServers": {
+    "nativesoul": {
+      "command": "nativesoul-mcp",
+      "args": []
+    }
+  },
+  "contextFileName": "GEMINI.md",
+  "excludeTools": [
+    "run_shell_command(rm -rf)",
+    "run_shell_command(git push)",
+    "run_shell_command(npm publish)"
+  ]
+}

package/plugins/gemini-nativesoul/hooks/hooks.json

@@ -0,0 +1,59 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${extensionPath}/shared/hooks/host-hook.cjs session-start --host gemini --project-env GEMINI_CWD",
+            "timeout": 9
+          }
+        ]
+      }
+    ],
+    "BeforeAgent": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${extensionPath}/shared/hooks/host-hook.cjs prompt-bootstrap --host gemini --project-env GEMINI_CWD --event BeforeAgent",
+            "timeout": 9
+          }
+        ]
+      }
+    ],
+    "BeforeTool": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${extensionPath}/shared/hooks/host-hook.cjs pre-tool-use --host gemini --project-env GEMINI_CWD --event BeforeTool",
+            "timeout": 9
+          }
+        ]
+      }
+    ],
+    "AfterAgent": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${extensionPath}/shared/hooks/host-hook.cjs memory-flush --host gemini --project-env GEMINI_CWD --event AfterAgent",
+            "timeout": 9
+          }
+        ]
+      }
+    ],
+    "PreCompress": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${extensionPath}/shared/hooks/host-hook.cjs memory-flush --host gemini --project-env GEMINI_CWD --event PreCompress",
+            "timeout": 9
+          }
+        ]
+      }
+    ]
+  }
+}

package/plugins/grok-nativesoul/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "nativesoul": {
+      "command": "nativesoul-mcp",
+      "args": []
+    }
+  }
+}

package/plugins/grok-nativesoul/AGENTS.md

@@ -0,0 +1,17 @@
+<!-- nativesoul:start v1 -->
+# NativeSoul bridge for Grok
+
+At the start of continuity-sensitive work, load NativeSoul context.
+
+Preferred path: use MCP `life_bootstrap` with `host="grok"` and the current working directory.
+
+Fallback path: run `nativesoul bootstrap --host grok --cwd <current-working-directory> --format inject --json`.
+
+Use `relevant_memories` for durable facts, `capability_cards` as advisory guidance, and `capabilities` only as the ready-only list.
+
+Native hooks and scheduler support are not declared unless Grok official documentation exposes them. Do not create cron, daemons, or sidecars.
+
+Never copy credentials or auto-edit `SOUL.md`/`POLICY.md`; propose those changes for approval.
+
+Host adapter: grok.
+<!-- nativesoul:end -->