gisool 0.0.0-stage → 0.1.0

package/dist/store/writes.js

@@ -0,0 +1,172 @@
+import { randomUUID } from "node:crypto";
+export function parseJson(text, fallback) {
+    if (typeof text !== "string" || text === "")
+        return fallback;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return fallback;
+    }
+}
+export function nameFromUri(uri) {
+    const parts = uri.split("/").filter(Boolean);
+    const last = parts[parts.length - 1];
+    return (last === "SKILL.md" ? parts[parts.length - 2] : last) ?? uri;
+}
+export function storeError(code, message = code) {
+    return Object.assign(new Error(message), { code });
+}
+const DAY_MS = 86_400_000;
+function refFromRow(row) {
+    const ref = { runtime: row.runtime };
+    if (row.runtime_session_id !== null)
+        ref.runtimeSessionId = row.runtime_session_id;
+    if (row.conversation_id !== null)
+        ref.conversationId = row.conversation_id;
+    if (row.client_name !== null)
+        ref.clientName = row.client_name;
+    if (row.cwd !== null)
+        ref.cwd = row.cwd;
+    return ref;
+}
+function getMeta(db, key) {
+    const row = db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
+    return row?.value ?? undefined;
+}
+function setMeta(db, key, value) {
+    db.prepare("INSERT INTO meta(key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, value);
+}
+export function readIngestCounters(db) {
+    const num = (k) => Number(getMeta(db, `ingest.${k}`) ?? 0);
+    const lastError = parseJson(getMeta(db, "ingest.lastError"), undefined);
+    return { accepted: num("accepted"), rejected: num("rejected"), dropped: num("dropped"), ...(lastError ? { lastError } : {}) };
+}
+export function readAliasesOverrides(db) {
+    return parseJson(getMeta(db, "aliases_overrides"), {});
+}
+export function writeAliasesOverrides(db, value) {
+    setMeta(db, "aliases_overrides", JSON.stringify(value));
+}
+export function createWrites(ctx) {
+    const { db } = ctx;
+    const insertEvent = db.prepare(`INSERT OR IGNORE INTO events
+    (id, ts, kind, source, session_id, attribution_method, attribution_reason, runtime, trace_id, load_id, skill_uri, tool_use_id, text, text_digest, text_length, data_json)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    const setFirstPrompt = db.prepare("UPDATE sessions SET first_prompt = ? WHERE id = ? AND first_prompt IS NULL");
+    const setEnded = db.prepare("UPDATE sessions SET ended_at = MAX(COALESCE(ended_at, 0), ?) WHERE id = ?");
+    function sessionSideEffects(sessionId, kind, ts, text) {
+        if (sessionId === "unattributed")
+            return;
+        if (kind === "prompt" && text !== null)
+            setFirstPrompt.run(text, sessionId);
+        if (kind === "session_end")
+            setEnded.run(ts, sessionId);
+    }
+    return {
+        append(event, attribution) {
+            const text = event.text ?? null;
+            insertEvent.run(event.id, event.ts, event.kind, event.source, attribution.sessionId, attribution.method, attribution.reason ?? null, event.ref.runtime, event.traceId ?? null, event.loadId ?? null, event.skillUri ?? null, event.toolUseId ?? null, text, event.textDigest ?? null, event.textLength ?? null, JSON.stringify(event.data ?? {}));
+            sessionSideEffects(attribution.sessionId, event.kind, event.ts, text);
+        },
+        openSessions(runtime, since) {
+            const rows = db.prepare(`SELECT s.*, MAX(s.started_at, COALESCE(MAX(e.ts), s.started_at)) AS last_activity
+        FROM sessions s LEFT JOIN events e ON e.session_id = s.id
+        WHERE s.runtime = ? AND s.ended_at IS NULL GROUP BY s.id HAVING last_activity >= ? ORDER BY last_activity DESC`)
+                .all(runtime, since);
+            return rows.map((r) => ({ id: r.id, startedAt: r.started_at, lastActivityAt: r.last_activity, ref: refFromRow(r) }));
+        },
+        reattribute(eventId, sessionId, method) {
+            db.prepare("UPDATE events SET session_id = ?, attribution_method = ?, attribution_reason = NULL WHERE id = ?").run(sessionId, method, eventId);
+            const ev = db.prepare("SELECT kind, ts, text FROM events WHERE id = ?").get(eventId);
+            if (ev)
+                sessionSideEffects(sessionId, ev.kind, ev.ts, ev.text);
+        },
+        findEventByToolUseId(toolUseId) {
+            const row = db.prepare("SELECT id FROM events WHERE tool_use_id = ? ORDER BY ts DESC, rowid DESC LIMIT 1").get(toolUseId);
+            return row?.id;
+        },
+        upsertSession(ref, startedAt) {
+            const key = ref.runtimeSessionId ?? ref.conversationId;
+            if (key !== undefined) {
+                const column = ref.runtimeSessionId !== undefined ? "runtime_session_id" : "conversation_id";
+                const existing = db.prepare(`SELECT * FROM sessions WHERE runtime = ? AND ${column} = ? ORDER BY started_at LIMIT 1`).get(ref.runtime, key);
+                if (existing) {
+                    db.prepare(`UPDATE sessions SET started_at = MIN(started_at, ?), conversation_id = COALESCE(conversation_id, ?),
+            runtime_session_id = COALESCE(runtime_session_id, ?), client_name = COALESCE(client_name, ?), cwd = COALESCE(cwd, ?) WHERE id = ?`)
+                        .run(startedAt, ref.conversationId ?? null, ref.runtimeSessionId ?? null, ref.clientName ?? null, ref.cwd ?? null, existing.id);
+                    return existing.id;
+                }
+            }
+            const id = randomUUID();
+            db.prepare("INSERT INTO sessions (id, runtime, runtime_session_id, conversation_id, client_name, cwd, started_at) VALUES (?, ?, ?, ?, ?, ?, ?)")
+                .run(id, ref.runtime, ref.runtimeSessionId ?? null, ref.conversationId ?? null, ref.clientName ?? null, ref.cwd ?? null, startedAt);
+            return id;
+        },
+        putLoad(load) {
+            db.prepare(`INSERT OR REPLACE INTO loads (load_id, trace_id, uri, manifest_digest, resources_json, created_at) VALUES (?, ?, ?, ?, ?, ?)`)
+                .run(load.loadId, load.traceId ?? null, load.uri, load.manifestDigest, JSON.stringify(load.resources), ctx.now());
+        },
+        getLoad(loadId) {
+            const row = db.prepare("SELECT uri, manifest_digest, resources_json FROM loads WHERE load_id = ?").get(loadId);
+            if (!row)
+                return undefined;
+            return { uri: row.uri, manifestDigest: row.manifest_digest, resources: parseJson(row.resources_json, []) };
+        },
+        latestLoad(uri) {
+            const row = db.prepare("SELECT load_id FROM loads WHERE uri = ? ORDER BY created_at DESC, rowid DESC LIMIT 1").get(uri);
+            return row?.load_id;
+        },
+        traceSession(traceId) {
+            const row = db.prepare("SELECT session_id FROM events WHERE trace_id = ? AND session_id != 'unattributed' ORDER BY ts, rowid LIMIT 1").get(traceId);
+            return row?.session_id;
+        },
+        upsertSkills(entries) {
+            const stmt = db.prepare(`INSERT INTO skills (uri, root_id, name, description, tags_json, when_to_use, examples_json, aliases_ko_json, group_id, group_stage,
+          invocation, body_head, digest, manifest_digest, resources_json, mtime_ms, removed_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL)
+        ON CONFLICT(uri) DO UPDATE SET root_id = excluded.root_id, name = excluded.name, description = excluded.description, tags_json = excluded.tags_json,
+          when_to_use = excluded.when_to_use, examples_json = excluded.examples_json, aliases_ko_json = excluded.aliases_ko_json, group_id = excluded.group_id,
+          group_stage = excluded.group_stage, invocation = excluded.invocation, body_head = excluded.body_head, digest = excluded.digest,
+          manifest_digest = excluded.manifest_digest, resources_json = excluded.resources_json, mtime_ms = excluded.mtime_ms, removed_at = NULL`);
+            db.exec("BEGIN");
+            try {
+                for (const e of entries) {
+                    stmt.run(e.uri, e.rootId, e.name, e.description, JSON.stringify(e.tags), e.whenToUse ?? null, JSON.stringify(e.examples), JSON.stringify(e.aliasesKo), e.group?.id ?? null, e.group?.stage ?? null, e.invocation, e.bodyHead, e.digest, e.manifestDigest, JSON.stringify(e.resources), e.mtimeMs);
+                }
+                db.exec("COMMIT");
+            }
+            catch (error) {
+                db.exec("ROLLBACK");
+                throw error;
+            }
+        },
+        markRemoved(uris) {
+            const stmt = db.prepare("UPDATE skills SET removed_at = ? WHERE uri = ? AND removed_at IS NULL");
+            const ts = ctx.now();
+            for (const uri of uris)
+                stmt.run(ts, uri);
+        },
+        countIngest(kind, code) {
+            db.prepare(`INSERT INTO meta(key, value) VALUES (?, '1') ON CONFLICT(key) DO UPDATE SET value = CAST(CAST(value AS INTEGER) + 1 AS TEXT)`).run(`ingest.${kind}`);
+            if (kind !== "accepted" && code !== undefined)
+                setMeta(db, "ingest.lastError", JSON.stringify({ ts: ctx.now(), code }));
+        },
+        addEvalCase(c) {
+            db.prepare("INSERT INTO eval_cases (id, query, expected_uri, from_trace_id, created_at) VALUES (?, ?, ?, ?, ?)")
+                .run(randomUUID(), c.query, c.expectedUri ?? null, c.fromTraceId ?? null, ctx.now());
+        },
+        evalCases() {
+            const rows = db.prepare("SELECT query, expected_uri FROM eval_cases ORDER BY created_at, rowid").all();
+            return rows.map((r) => (r.expected_uri === null ? { query: r.query } : { query: r.query, expectedUri: r.expected_uri }));
+        },
+        retention(days) {
+            if (ctx.opts.config && ctx.opts.config.retentionDays === null)
+                return 0;
+            const cutoff = ctx.now() - days * DAY_MS;
+            const result = db.prepare("UPDATE events SET text = NULL WHERE ts < ? AND text IS NOT NULL").run(cutoff);
+            db.prepare("UPDATE sessions SET first_prompt = NULL WHERE started_at < ? AND first_prompt IS NOT NULL").run(cutoff);
+            return Number(result.changes);
+        },
+    };
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/version.js

@@ -0,0 +1,19 @@
+export class GisoolStartupError extends Error {
+    code;
+    constructor(code, message) {
+        super(message ? `${code}: ${message}` : code);
+        this.name = "GisoolStartupError";
+        this.code = code;
+    }
+}
+export const MIN_NODE = [24, 15];
+export function assertNodeVersion(version = process.versions.node) {
+    const [major = 0, minor = 0] = version.split(".").map((part) => Number.parseInt(part, 10));
+    if (major < MIN_NODE[0] || (major === MIN_NODE[0] && minor < MIN_NODE[1])) {
+        throw new GisoolStartupError("node_too_old", `gisool needs Node >= ${MIN_NODE.join(".")}, found ${version}`);
+    }
+}
+export function assertPlatform(platform = process.platform) {
+    if (platform === "win32")
+        throw new GisoolStartupError("unsupported_platform", "gisool supports macOS and Linux");
+}

package/package.json

@@ -1,6 +1,48 @@
 {
   "name": "gisool",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "private": false,
+  "description": "Local skill router for coding agents: search your skills, trace how agents use them, and see the flow.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/changeroa/gisool.git",
+    "directory": "local"
+  },
+  "homepage": "https://github.com/changeroa/gisool/tree/main/local#readme",
+  "files": [
+    "dist",
+    "packs",
+    "src/store/schema.sql",
+    "src/store/task-types.json",
+    "README.md"
+  ],
+  "type": "module",
+  "bin": {
+    "gisool": "dist/cli/main.js"
+  },
+  "engines": {
+    "node": ">=24.15"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node build-dashboard.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p dashboard/tsconfig.json",
+    "test": "node --test \"test/**/*.test.mjs\"",
+    "start": "node dist/cli/main.js serve"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.30.0",
+    "express": "^5.2.1",
+    "yaml": "^2.9.0",
+    "zod": "^4.1.11"
+  },
+  "devDependencies": {
+    "@types/d3-sankey": "^0.12.4",
+    "@types/express": "^5.0.5",
+    "@types/node": "^24.3.0",
+    "d3-sankey": "0.12.3",
+    "esbuild": "^0.28.2",
+    "preact": "^10.27.2",
+    "typescript": "^5.9.2"
+  }
+}

package/packs/claude-code/README.md

@@ -0,0 +1,5 @@
+# Claude Code capture pack
+
+Template merged into `~/.claude/settings.json` by `gisool init`: OTel log export (`env`) plus
+`PostToolUse` / `UserPromptExpansion` hooks that run `packs/hook-post.mjs`. `~/.claude.json` is never edited;
+the MCP server is registered with `claude mcp add --scope user` (or printed as a manual step).

package/packs/claude-code/settings.template.json

@@ -0,0 +1,24 @@
+{
+  "env": {
+    "CLAUDE_CODE_ENABLE_TELEMETRY": "1",
+    "OTEL_LOGS_EXPORTER": "otlp",
+    "OTEL_EXPORTER_OTLP_LOGS_PROTOCOL": "http/json",
+    "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT": "http://127.0.0.1:{{PORT}}/ingest/otlp/v1/logs",
+    "OTEL_EXPORTER_OTLP_LOGS_HEADERS": "Authorization=Bearer {{TOKEN}}",
+    "OTEL_LOG_USER_PROMPTS": "1",
+    "OTEL_LOG_TOOL_DETAILS": "1"
+  },
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Skill|mcp__gisool__.*",
+        "hooks": [{ "type": "command", "command": "\"{{NODE}}\" \"{{HOOK}}\" claude-code", "timeout": 5 }]
+      }
+    ],
+    "UserPromptExpansion": [
+      {
+        "hooks": [{ "type": "command", "command": "\"{{NODE}}\" \"{{HOOK}}\" claude-code", "timeout": 5 }]
+      }
+    ]
+  }
+}

package/packs/codex/README.md

@@ -0,0 +1,5 @@
+# Codex capture pack
+
+`config.template.toml` is the block `gisool init` keeps between `# >>> gisool managed` and `# <<< gisool managed`
+in `~/.codex/config.toml` (MCP entry and `[otel]`). No Codex hooks are installed (they need trust review).
+Note: `codex exec` exports OTel events only partially.

package/packs/codex/config.template.toml

@@ -0,0 +1,11 @@
+# >>> gisool managed
+# Managed by gisool; edit via `gisool init`, not by hand.
+[mcp_servers.gisool]
+url = "http://127.0.0.1:{{PORT}}/mcp"
+http_headers = { Authorization = "Bearer {{TOKEN}}" }
+
+[otel]
+log_user_prompt = true
+exporter = { otlp-http = { endpoint = "http://127.0.0.1:{{PORT}}/ingest/otlp/v1/logs", protocol = "json", headers = { Authorization = "Bearer {{TOKEN}}" } } }
+metrics_exporter = "none"
+# <<< gisool managed

package/packs/cursor/hooks.example.json

@@ -0,0 +1,8 @@
+{
+  "version": 1,
+  "hooks": {
+    "beforeSubmitPrompt": [{ "command": "\"<nodePath>\" \"<packageRoot>/packs/hook-post.mjs\" cursor" }],
+    "sessionStart": [{ "command": "\"<nodePath>\" \"<packageRoot>/packs/hook-post.mjs\" cursor" }],
+    "sessionEnd": [{ "command": "\"<nodePath>\" \"<packageRoot>/packs/hook-post.mjs\" cursor" }]
+  }
+}

package/packs/cursor/mcp.example.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "gisool": {
+      "url": "http://127.0.0.1:8799/mcp",
+      "headers": { "Authorization": "Bearer <token>" }
+    }
+  }
+}

package/packs/gajae/extension/discovery.md

@@ -0,0 +1,5 @@
+# gisool discovery
+
+gisool = local skills on this machine; gisul = remote team skills. They are separate catalogs: search both when a task could be served by either.
+
+Before substantive work on a new actionable task, call the gisool MCP `search_skills` tool with mode: discovery and 2-5 terms describing the subject and intended outcome. Reuse results for unchanged continuations. If the result is empty or unrelated, retry once with a shorter subject, then proceed without a local skill. Search only discovers candidates: pick by concrete relevance, then load the chosen skill with the gisool `load_skill` tool using its exact URI. An explicit-only candidate needs the user to ask for that specific skill.

package/packs/gajae/extension/index.js

@@ -0,0 +1,44 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const RUNTIME = "gajae";
+const MARKER = "<gisool-discovery>";
+const readText = url => { try { return readFileSync(url, "utf8"); } catch { return ""; } };
+
+const guidance = readText(new URL("./discovery.md", import.meta.url)).trim();
+let configured = {};
+try { configured = JSON.parse(readText(new URL("./config.json", import.meta.url))); } catch {}
+const port = process.env.GISOOL_PORT || configured.port || 8799;
+const url = `http://127.0.0.1:${port}/ingest/hook/${RUNTIME}`;
+// Read once at module load; never on the agent path.
+const token = readText(join(process.env.GISOOL_HOME || join(homedir(), ".gisool"), "token")).trim();
+
+function forward(event, ctx) {
+  const prompt = typeof event.prompt === "string" ? event.prompt : null;
+  const body = {
+    event: "before_agent_start",
+    prompt,
+    sessionId: ctx?.sessionManager?.getSessionId?.(),
+    cwd: ctx?.cwd ?? process.cwd(),
+  };
+  if (prompt === null) body.promptUnavailable = true;
+  // Fire-and-forget: the agent path never waits on gisool.
+  fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(2000),
+  }).catch(() => {});
+}
+
+export default function gisool(pi) {
+  pi.on("before_agent_start", (event, ctx) => {
+    if (!event || event.preview === true) return event;
+    try { forward(event, ctx); } catch {}
+    if (guidance && typeof event.systemPrompt === "string" && !event.systemPrompt.includes(MARKER)) {
+      event.systemPrompt = `${event.systemPrompt}\n\n${MARKER}\n${guidance}\n</gisool-discovery>`;
+    }
+    return event;
+  }, { previewSafe: true });
+}

package/packs/gemini/settings.example.json

@@ -0,0 +1,16 @@
+{
+  "mcpServers": {
+    "gisool": {
+      "httpUrl": "http://127.0.0.1:8799/mcp",
+      "headers": { "Authorization": "Bearer <token>" }
+    }
+  },
+  "hooks": {
+    "BeforeAgent": [
+      { "hooks": [{ "type": "command", "name": "gisool-capture", "command": "\"<nodePath>\" \"<packageRoot>/packs/hook-post.mjs\" gemini", "timeout": 5000 }] }
+    ],
+    "AfterTool": [
+      { "matcher": "activate_skill", "hooks": [{ "type": "command", "name": "gisool-capture", "command": "\"<nodePath>\" \"<packageRoot>/packs/hook-post.mjs\" gemini", "timeout": 5000 }] }
+    ]
+  }
+}

package/packs/hook-post.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+// Forwards a runtime hook payload (stdin JSON) to the local gisool daemon. Always exits 0.
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const done = () => process.exit(0);
+try {
+  const runtime = process.argv[2] ?? "unknown";
+  const home = process.env.GISOOL_HOME || join(homedir(), ".gisool");
+  const body = await new Promise(resolve => {
+    const chunks = [];
+    const timer = setTimeout(() => resolve(Buffer.concat(chunks).toString("utf8")), 1000);
+    process.stdin.on("data", c => chunks.push(c));
+    process.stdin.on("end", () => { clearTimeout(timer); resolve(Buffer.concat(chunks).toString("utf8")); });
+    process.stdin.on("error", () => { clearTimeout(timer); resolve(""); });
+  });
+  const token = readFileSync(join(home, "token"), "utf8").trim();
+  const { port } = JSON.parse(readFileSync(join(home, "config.json"), "utf8"));
+  if (body && token && Number.isInteger(port)) {
+    await fetch(`http://127.0.0.1:${port}/ingest/hook/${encodeURIComponent(runtime)}`, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+      body,
+      signal: AbortSignal.timeout(2000),
+    });
+  }
+} catch { /* never block the agent */ }
+done();

package/packs/omo/extension/discovery.md

@@ -0,0 +1,5 @@
+# gisool discovery
+
+gisool = local skills on this machine; gisul = remote team skills. They are separate catalogs: search both when a task could be served by either.
+
+Before substantive work on a new actionable task, call the gisool MCP `search_skills` tool with mode: discovery and 2-5 terms describing the subject and intended outcome. Reuse results for unchanged continuations. If the result is empty or unrelated, retry once with a shorter subject, then proceed without a local skill. Search only discovers candidates: pick by concrete relevance, then load the chosen skill with the gisool `load_skill` tool using its exact URI. An explicit-only candidate needs the user to ask for that specific skill.

package/packs/omo/extension/index.js

@@ -0,0 +1,44 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const RUNTIME = "omo";
+const MARKER = "<gisool-discovery>";
+const readText = url => { try { return readFileSync(url, "utf8"); } catch { return ""; } };
+
+const guidance = readText(new URL("./discovery.md", import.meta.url)).trim();
+let configured = {};
+try { configured = JSON.parse(readText(new URL("./config.json", import.meta.url))); } catch {}
+const port = process.env.GISOOL_PORT || configured.port || 8799;
+const url = `http://127.0.0.1:${port}/ingest/hook/${RUNTIME}`;
+// Read once at module load; never on the agent path.
+const token = readText(join(process.env.GISOOL_HOME || join(homedir(), ".gisool"), "token")).trim();
+
+function forward(event, ctx) {
+  const prompt = typeof event.prompt === "string" ? event.prompt : null;
+  const body = {
+    event: "before_agent_start",
+    prompt,
+    sessionId: ctx?.sessionManager?.getSessionId?.(),
+    cwd: ctx?.cwd ?? process.cwd(),
+  };
+  if (prompt === null) body.promptUnavailable = true;
+  // Fire-and-forget: the agent path never waits on gisool.
+  fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(2000),
+  }).catch(() => {});
+}
+
+export default function gisool(pi) {
+  pi.on("before_agent_start", (event, ctx) => {
+    if (!event || event.preview === true) return event;
+    try { forward(event, ctx); } catch {}
+    if (guidance && typeof event.systemPrompt === "string" && !event.systemPrompt.includes(MARKER)) {
+      event.systemPrompt = `${event.systemPrompt}\n\n${MARKER}\n${guidance}\n</gisool-discovery>`;
+    }
+    return event;
+  }, { previewSafe: true });
+}

package/packs/openclaw/.codex-plugin/plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "gisool",
+  "version": "0.1.0",
+  "description": "Capture OpenClaw prompts and expose the local gisool skill router.",
+  "author": {
+    "name": "ARKPOINT"
+  },
+  "hooks": "./hooks/",
+  "mcpServers": "./.mcp.json",
+  "license": "MIT"
+}

package/packs/openclaw/.mcp.json

@@ -0,0 +1,12 @@
+{
+  "mcpServers": {
+    "gisool": {
+      "transport": "stdio",
+      "command": "__COMMAND__",
+      "args": "__ARGS__",
+      "env": {
+        "GISOOL_HOME": "__GISOOL_HOME__"
+      }
+    }
+  }
+}

package/packs/openclaw/gisool.json

@@ -0,0 +1 @@
+{ "port": "__PORT__" }

package/packs/openclaw/hooks/gisool-discovery/HOOK.md

@@ -0,0 +1,8 @@
+---
+name: gisool-discovery
+description: Add gisool skill discovery guidance to OpenClaw's in-memory agent bootstrap.
+metadata: { "openclaw": { "events": ["agent:bootstrap"] } }
+---
+
+Appends a small discovery instruction to the in-memory AGENTS.md bootstrap entry.
+Existing instructions are preserved; no workspace files are written.

package/packs/openclaw/hooks/gisool-discovery/handler.js

@@ -0,0 +1,27 @@
+import { join } from "node:path";
+
+export const marker = "<gisool-discovery>";
+export const guidance = `${marker}
+gisool = local skills on this machine; gisul = remote team skills.
+Before substantive work on a new actionable task, use the gisool search_skills tool
+(MCP server "gisool") with 2-5 subject/outcome terms. Search is not activation:
+check relevance and invocation, then load only a relevant result's exact URI and
+read its complete instructions. If results are empty or unrelated, retry once with
+a shorter subject, then proceed. Greetings and unchanged-task continuations need no
+new search. Respect a user ban on skill lookup. If the tools are unavailable, say so
+briefly and continue.
+</gisool-discovery>`;
+
+export default function handler(event) {
+  if (event.type !== "agent" || event.action !== "bootstrap") return;
+  const files = event.context?.bootstrapFiles;
+  if (!Array.isArray(files)) return;
+  if (files.some(file => file.content?.includes(marker))) return;
+  const index = files.findIndex(file => file.name === "AGENTS.md");
+  if (index >= 0) {
+    const file = files[index];
+    files[index] = { ...file, content: [file.content, guidance].filter(Boolean).join("\n\n"), missing: false };
+  } else if (event.context.workspaceDir) {
+    files.push({ name: "AGENTS.md", path: join(event.context.workspaceDir, "AGENTS.md"), content: guidance, missing: false });
+  }
+}

package/packs/openclaw/index.mjs

@@ -0,0 +1,47 @@
+// gisool capture plugin: forwards each agent run's prompt to the local gisool daemon.
+// Needs plugins.entries.gisool.hooks.allowConversationAccess: true in the OpenClaw config.
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const here = new URL(".", import.meta.url);
+
+function loadPort(env) {
+  if (env.GISOOL_PORT) return Number(env.GISOOL_PORT);
+  try {
+    return Number(JSON.parse(readFileSync(new URL("gisool.json", here), "utf8")).port);
+  } catch {
+    return NaN;
+  }
+}
+
+/** Fire-and-forget POST; never throws, never awaited by the hook. */
+export function forward(payload, env = process.env) {
+  try {
+    const port = loadPort(env);
+    const token = readFileSync(join(env.GISOOL_HOME || join(homedir(), ".gisool"), "token"), "utf8").trim();
+    if (!Number.isInteger(port) || !token) return;
+    fetch(`http://127.0.0.1:${port}/ingest/hook/openclaw`, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(2000),
+    }).catch(() => {});
+  } catch {
+    // capture must never affect the agent run
+  }
+}
+
+export function register(api, env = process.env) {
+  if (typeof api.on === "function") {
+    api.on("before_agent_run", (event, ctx) => {
+      forward({ event: "before_agent_run", prompt: event?.prompt ?? null, sessionKey: ctx?.sessionKey, sessionId: ctx?.sessionId }, env);
+    });
+  } else if (typeof api.registerHook === "function") {
+    api.registerHook("message:received", (event) => {
+      forward({ event: "message_received", via: "message_received", prompt: event?.context?.content ?? null, sessionKey: event?.sessionKey }, env);
+    });
+  }
+}
+
+export default { id: "gisool", name: "gisool", description: "Capture prompts for the local gisool skill router.", register };

package/packs/openclaw/openclaw.plugin.json

@@ -0,0 +1,22 @@
+{
+  "id": "gisool",
+  "name": "gisool",
+  "description": "Capture OpenClaw prompts for the local gisool skill router.",
+  "activation": {
+    "onStartup": true
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false
+  },
+  "mcpServers": {
+    "gisool": {
+      "transport": "stdio",
+      "command": "__COMMAND__",
+      "args": "__ARGS__",
+      "env": {
+        "GISOOL_HOME": "__GISOOL_HOME__"
+      }
+    }
+  }
+}

package/packs/openclaw/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "gisool-openclaw",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "openclaw": {
+    "extensions": [
+      "./index.mjs"
+    ]
+  }
+}