argocd-axi 0.1.6 → 0.1.7

package/README.md

@@ -121,14 +121,20 @@ and every other command that prints or changes a credential.
 
 Pick one; you do not need both.
 
-- **Session hook (recommended).** `argocd-axi setup hooks` installs a
-  SessionStart hook for Claude Code, Codex and OpenCode. The hook runs
-  `argocd-axi-ctx`, which is local only: current context, server, CLI version
-  and the cached server version. It makes no network call, triggers no SSO
-  refresh and reads no credential, so a dead context can never hang a session
-  start. It needs a persistent install (`npm install -g argocd-axi`); run from
-  an npx cache, it answers `REFUSED` because the hook would point at a
-  temporary path.
+- **Session hook (recommended).** `argocd-axi setup hooks` installs
+  SessionStart hooks for Claude Code, Codex and OpenCode, plus a Claude Code
+  SessionEnd hook. The start hook runs `argocd-axi-ctx`, which is local only:
+  current context, server, CLI version and the cached server version. It makes
+  no network call, triggers no SSO refresh and reads no credential, so a dead
+  context can never hang a session start. The end hook records only argocd-axi
+  command names, their counts and the most-used `--context` value for that
+  working directory; it does not save arguments or other values. The session
+  log is limited to 100 directories and stored with `0600` permissions. Run
+  `argocd-axi context` to view the current directory's last session, or
+  `argocd-axi setup status` / `argocd-axi setup uninstall` to inspect or remove
+  the Claude Code SessionEnd hook. Hooks need a persistent install
+  (`npm install -g argocd-axi`); run from an npx cache, installation is refused
+  because hooks would point at a temporary path.
 - **Skill.** `npx skills add Dematom1/argocd-axi --skill argocd-axi`
   installs [`skills/argocd-axi/SKILL.md`](skills/argocd-axi/SKILL.md), which
   is generated from the CLI's own help and loads when a task is about Argo CD.
@@ -156,7 +162,8 @@ argocd-axi apps actions run <app> <action> --kind <k> --name <resource> [--confi
 argocd-axi projects | projects view <p> | projects windows <p>
 argocd-axi appsets | appsets view <name> | appsets generate <file>
 argocd-axi repos | clusters
-argocd-axi setup hooks
+argocd-axi context [end]
+argocd-axi setup hooks | status | uninstall
 argocd-axi update [--check]
 ```
 

package/dist/src/cli.js

@@ -10,6 +10,7 @@ import { homeCommand } from "./commands/home.js";
 import { clustersCommand, reposCommand } from "./commands/inventory.js";
 import { projectsCommand } from "./commands/projects.js";
 import { setupCommand } from "./commands/setup.js";
+import { contextCommand } from "./commands/context.js";
 import { DESCRIPTION, TOP_HELP } from "./help.js";
 import { NATIVE_NOUNS, REFUSALS } from "./registry.js";
 import { renderBlocks, renderHelp } from "./toon.js";
@@ -55,6 +56,7 @@ export const COMMANDS = Object.assign(Object.create(null), {
     repos: reposCommand,
     clusters: clustersCommand,
     setup: setupCommand,
+    context: contextCommand,
     ...Object.fromEntries(TOP_LEVEL_REFUSALS.map((key) => [key, refusalCommand(key)])),
 });
 export async function main(argv = process.argv.slice(2)) {

package/dist/src/commands/context.js

@@ -0,0 +1,83 @@
+import { realpathSync } from "node:fs";
+import { parseArgs } from "../args.js";
+import { CODES, axiError } from "../errors.js";
+import { encodeObject } from "../toon.js";
+import { finish } from "./common.js";
+import { lastSession, recordSession, sessionText, summarizeTranscript, } from "../sessionlog.js";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function directory(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return path;
+    }
+}
+function display(summary) {
+    return summary ? sessionText(summary) : undefined;
+}
+const CONTEXT_SPEC = {
+    path: "context",
+    summary: "Show or record session memory",
+    positionals: [{ name: "action", required: false, description: "end" }],
+    flags: [],
+    examples: ["argocd-axi context", "argocd-axi context end"],
+};
+export async function contextCommand(args) {
+    const parsed = parseArgs(CONTEXT_SPEC, args);
+    const sub = parsed.positionals[0];
+    if (sub !== undefined && sub !== "end") {
+        throw axiError("unknown context action", CODES.VALIDATION_ERROR, [
+            "Run `argocd-axi context` or `argocd-axi context end`",
+        ]);
+    }
+    if (sub !== "end") {
+        const summary = display(lastSession(directory(process.cwd())));
+        return finish([encodeObject({ last_session: summary })], undefined);
+    }
+    if (process.stdin.isTTY)
+        throw axiError("context end reads a SessionEnd hook payload on stdin", CODES.VALIDATION_ERROR, ["It runs from the hook installed by `argocd-axi setup hooks`"]);
+    let payload;
+    try {
+        payload = JSON.parse(await new Promise((resolve, reject) => {
+            let text = "";
+            process.stdin.setEncoding("utf8");
+            process.stdin.on("data", (chunk) => (text += chunk));
+            process.stdin.on("end", () => resolve(text));
+            process.stdin.on("error", reject);
+        }));
+    }
+    catch {
+        return finish([encodeObject({ recorded: "nothing - stdin is not a hook payload" })], undefined);
+    }
+    if (!isRecord(payload) || typeof payload.transcript_path !== "string")
+        return finish([encodeObject({ recorded: "nothing - payload has no transcript_path" })], undefined);
+    let summary;
+    try {
+        summary = await summarizeTranscript(payload.transcript_path);
+    }
+    catch {
+        return finish([encodeObject({ recorded: "nothing - transcript could not be read" })], undefined);
+    }
+    if (!summary)
+        return finish([
+            encodeObject({
+                recorded: "nothing - no argocd-axi commands this session",
+            }),
+        ], undefined);
+    const cwd = typeof payload.cwd === "string" ? payload.cwd : process.cwd();
+    try {
+        if (!(await recordSession(directory(cwd), summary)))
+            return finish([encodeObject({ recorded: "nothing - session log is busy" })], undefined);
+    }
+    catch {
+        return finish([
+            encodeObject({
+                recorded: "nothing - session log could not be written",
+            }),
+        ], undefined);
+    }
+    return finish([encodeObject({ recorded: sessionText(summary) })], undefined);
+}

package/dist/src/commands/setup.js

@@ -6,14 +6,16 @@ import { parseArgs, renderCommandHelp } from "../args.js";
 import { CODES, axiError, validationError } from "../errors.js";
 import { encodeObject } from "../toon.js";
 import { finish } from "./common.js";
+import { installSessionEndHook, sessionEndHookStatus, uninstallSessionEndHook, } from "../session-hook.js";
 export const SETUP_HOOKS_SPEC = {
     path: "setup hooks",
-    summary: "Install or repair SessionStart hooks for Claude Code, Codex and OpenCode",
+    summary: "Install, inspect or remove agent session hooks",
     positionals: [],
     flags: [],
     examples: ["argocd-axi setup hooks"],
     notes: [
         "The hook runs `argocd-axi-ctx`, which is local only: current context, server and CLI version, with no network call, no SSO refresh and no credential read",
+        "SessionEnd records command names, counts and the most-used --context value only; setup status and setup uninstall inspect or remove that Claude Code hook",
         "Intended for global installs; repeated runs are no-ops",
     ],
 };
@@ -29,16 +31,31 @@ function ctxEntrypoint() {
         : join(here, "..", "..", "bin", "argocd-axi-ctx.ts");
 }
 export async function setupCommand(args) {
-    if (args[0] !== "hooks") {
+    const action = args[0];
+    if (action !== "hooks" && action !== "status" && action !== "uninstall") {
         if (args.includes("--help"))
             return renderCommandHelp(SETUP_HOOKS_SPEC);
         throw validationError("unknown setup action", [
-            "Run `argocd-axi setup hooks`",
+            "Run `argocd-axi setup hooks`, `argocd-axi setup status` or `argocd-axi setup uninstall`",
         ]);
     }
     if (args.includes("--help"))
         return renderCommandHelp(SETUP_HOOKS_SPEC);
     parseArgs(SETUP_HOOKS_SPEC, args.slice(1));
+    if (action === "status")
+        return finish([
+            encodeObject({
+                sessionEnd: sessionEndHookStatus() ? "installed" : "not installed",
+            }),
+        ], undefined);
+    if (action === "uninstall")
+        return finish([
+            encodeObject({
+                sessionEnd: uninstallSessionEndHook()
+                    ? "removed"
+                    : "not installed (no-op)",
+            }),
+        ], undefined);
     // An npx (or pnpm dlx, bunx) run lives in a cache that later sessions may
     // not have on PATH or may have evicted, so a hook pointing at it would
     // silently stop working. Require a persistent install instead.
@@ -56,6 +73,12 @@ export async function setupCommand(args) {
         distEntrypoints: ["dist/bin/argocd-axi-ctx.js"],
         onError: (message) => errors.push(message),
     });
+    try {
+        installSessionEndHook();
+    }
+    catch (error) {
+        errors.push(error instanceof Error ? error.message : String(error));
+    }
     if (errors.length > 0) {
         throw axiError(`hook installation reported problems: ${errors.join("; ")}`, CODES.UPSTREAM_ERROR, ["Re-run `argocd-axi setup hooks` after fixing the paths above"]);
     }

package/dist/src/help.js

@@ -4,6 +4,8 @@ export const DESCRIPTION = "Argo CD for agents: read operations plus opt-in writ
 export const COMMAND_LINES = [
     "(no command): live overview - context, server, user, apps needing attention with the reason, running operations",
     "ctx [--context <c>]: current context, server and CLI version, local only (what the session hook prints)",
+    "context: last session's argocd-axi command summary for this directory",
+    "context end: record the current Claude Code session summary (SessionEnd hook)",
     "ctx use <context>: switch the argocd CLI's current context (local config only)",
     "auth guide [--context <c>]: offline human login and agent token setup instructions",
     "whoami: user, issuer and groups of the current credential",
@@ -26,7 +28,7 @@ export const COMMAND_LINES = [
     "projects | projects view <p> | projects windows <p>: projects, their rules, and whether sync is allowed now",
     "appsets | appsets view <name> | appsets generate <file>: ApplicationSets and what a spec would generate",
     "repos | clusters: repositories and destination clusters with connection status",
-    "setup hooks: install the SessionStart hook (runs the offline ctx view)",
+    "setup hooks | status | uninstall: manage the Claude Code SessionEnd memory hook; setup hooks also installs SessionStart hooks",
 ];
 export const TOP_HELP = `${renderBlocks([
     "usage: argocd-axi <command> [args] [flags]",

package/dist/src/session-hook.js

@@ -0,0 +1,117 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const path = () => join(process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude"), "settings.json");
+const command = "argocd-axi context end";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function settings() {
+    const file = path();
+    if (!existsSync(file))
+        return {};
+    const value = JSON.parse(readFileSync(file, "utf8"));
+    if (!isRecord(value))
+        throw new Error(`${file} is not a JSON object`);
+    return value;
+}
+function writeSettings(value) {
+    const file = path();
+    mkdirSync(join(file, ".."), { recursive: true });
+    const mode = existsSync(file) ? statSync(file).mode & 0o777 : 0o600;
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode });
+        chmodSync(temporary, mode);
+        renameSync(temporary, file);
+    }
+    catch (error) {
+        try {
+            unlinkSync(temporary);
+        }
+        catch {
+            /* No temporary file to remove. */
+        }
+        throw error;
+    }
+}
+export function installSessionEndHook() {
+    const value = settings();
+    const hooks = isRecord(value.hooks) ? value.hooks : {};
+    value.hooks = hooks;
+    const groups = Array.isArray(hooks.SessionEnd) ? hooks.SessionEnd : [];
+    const next = [];
+    let installed = false;
+    for (const group of groups) {
+        if (!isRecord(group) || !Array.isArray(group.hooks)) {
+            next.push(group);
+            continue;
+        }
+        const kept = group.hooks.filter((entry) => {
+            const ours = isRecord(entry) &&
+                (entry.command === command ||
+                    (typeof entry.command === "string" &&
+                        entry.command.endsWith("/argocd-axi context end")));
+            if (ours && !installed) {
+                installed = true;
+                return false;
+            }
+            return !ours;
+        });
+        if (kept.length)
+            next.push({ ...group, hooks: kept });
+    }
+    next.push({
+        matcher: "",
+        hooks: [{ type: "command", command, timeout: 30 }],
+    });
+    hooks.SessionEnd = next;
+    writeSettings(value);
+}
+export function sessionEndHookStatus() {
+    try {
+        const hooks = settings().hooks;
+        const groups = isRecord(hooks) ? hooks.SessionEnd : undefined;
+        return (Array.isArray(groups) &&
+            groups.some((group) => isRecord(group) &&
+                Array.isArray(group.hooks) &&
+                group.hooks.some((entry) => isRecord(entry) &&
+                    (entry.command === command ||
+                        (typeof entry.command === "string" &&
+                            entry.command.endsWith("/argocd-axi context end"))))));
+    }
+    catch {
+        return false;
+    }
+}
+export function uninstallSessionEndHook() {
+    const value = settings();
+    const hooks = value.hooks;
+    if (!isRecord(hooks) || !Array.isArray(hooks.SessionEnd))
+        return false;
+    let removed = false;
+    const next = hooks.SessionEnd.flatMap((group) => {
+        if (!isRecord(group) || !Array.isArray(group.hooks))
+            return [group];
+        const entries = group.hooks.filter((entry) => {
+            const ours = isRecord(entry) &&
+                (entry.command === command ||
+                    (typeof entry.command === "string" &&
+                        entry.command.endsWith("/argocd-axi context end")));
+            removed ||= ours;
+            return !ours;
+        });
+        return entries.length ? [{ ...group, hooks: entries }] : [];
+    });
+    if (!removed)
+        return false;
+    if (next.length)
+        hooks.SessionEnd = next;
+    else
+        delete hooks.SessionEnd;
+    if (Object.keys(hooks).length === 0)
+        delete value.hooks;
+    writeSettings(value);
+    return true;
+}

package/dist/src/sessionlog.js

@@ -0,0 +1,347 @@
+import { chmodSync, closeSync, createReadStream, mkdirSync, openSync, readdirSync, readFileSync, renameSync, rmdirSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { dirname, join } from "node:path";
+import { createInterface } from "node:readline";
+import { configPath } from "./config.js";
+const MAX_DIRECTORIES = 100;
+const LOCK_WAIT_MS = 2_000;
+const STALE_LOCK_MS = 30_000;
+const MAX_TRANSCRIPT_BYTES = 256 * 1024 * 1024;
+const TOOL = "argocd-axi";
+const COMMANDS = new Set([
+    "apps",
+    "projects",
+    "appsets",
+    "repos",
+    "clusters",
+    "ctx",
+    "auth",
+    "whoami",
+    "can-i",
+    "setup",
+    "context",
+]);
+const CONTEXTS = new Set([
+    "apps",
+    "projects",
+    "appsets",
+    "repos",
+    "clusters",
+    "ctx",
+    "auth",
+    "whoami",
+    "can-i",
+]);
+/** Split shell words without retaining anything in the persisted result. */
+function words(command) {
+    const result = [];
+    let token = "";
+    let quote = "";
+    let started = false;
+    const end = () => {
+        if (started)
+            result.push(token);
+        token = "";
+        started = false;
+    };
+    for (let i = 0; i < command.length; i++) {
+        const c = command[i];
+        if (quote) {
+            if (c === quote)
+                quote = "";
+            else if (c === "\\" && quote === '"' && i + 1 < command.length)
+                token += command[++i];
+            else
+                token += c;
+        }
+        else if (c === "'" || c === '"') {
+            quote = c;
+            started = true;
+        }
+        else if (c === "\\" && i + 1 < command.length) {
+            token += command[++i];
+            started = true;
+        }
+        else if (/\s|[;|&()`]/.test(c))
+            end();
+        else {
+            token += c;
+            started = true;
+        }
+    }
+    end();
+    return result;
+}
+function commandParts(line) {
+    const parts = [];
+    let quote = "";
+    let start = 0;
+    for (let i = 0; i < line.length; i++) {
+        const c = line[i];
+        if (quote) {
+            if (c === "\\" && quote === '"')
+                i++;
+            else if (c === quote)
+                quote = "";
+        }
+        else if (c === "\\")
+            i++;
+        else if (c === "'" || c === '"')
+            quote = c;
+        else if (/[;|&\n]/.test(c)) {
+            parts.push(line.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(line.slice(start));
+    return parts;
+}
+function commandCalls(line) {
+    const calls = [];
+    for (const part of commandParts(line)) {
+        const args = words(part);
+        const index = args.findIndex((word) => word.split("/").pop()?.replace(/\.js$/, "") === TOOL);
+        if (index < 0)
+            continue;
+        const argsAfter = args.slice(index + 1);
+        const command = argsAfter.find((arg) => !arg.startsWith("-"));
+        if (!command || !COMMANDS.has(command))
+            continue;
+        const contextArg = argsAfter.findIndex((arg) => arg === "--context");
+        const contextValue = contextArg >= 0
+            ? argsAfter[contextArg + 1]
+            : argsAfter.find((arg) => arg.startsWith("--context="))?.slice(10);
+        calls.push({
+            command,
+            ...(contextValue && CONTEXTS.has(command.split(" ")[0])
+                ? { context: contextValue }
+                : {}),
+        });
+    }
+    return calls;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function* toolCommands(value) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            yield* toolCommands(item);
+        return;
+    }
+    if (!isRecord(value))
+        return;
+    if (value.type === "tool_use") {
+        if (isRecord(value.input) && typeof value.input.command === "string")
+            yield value.input.command;
+        return;
+    }
+    for (const key of ["message", "content"])
+        if (key in value)
+            yield* toolCommands(value[key]);
+}
+export async function summarizeTranscript(path) {
+    if (statSync(path).size > MAX_TRANSCRIPT_BYTES)
+        return undefined;
+    const counts = {};
+    const contexts = [];
+    const lines = createInterface({
+        input: createReadStream(path, { encoding: "utf8" }),
+        crlfDelay: Infinity,
+    });
+    for await (const line of lines) {
+        if (!line.includes(TOOL))
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        for (const commandLine of toolCommands(entry))
+            for (const call of commandCalls(commandLine)) {
+                counts[call.command] = (counts[call.command] ?? 0) + 1;
+                if (call.context)
+                    contexts.push(call.context);
+            }
+    }
+    if (Object.keys(counts).length === 0)
+        return undefined;
+    const contextCounts = new Map();
+    for (const context of contexts)
+        contextCounts.set(context, (contextCounts.get(context) ?? 0) + 1);
+    const context = [...contextCounts].sort((a, b) => b[1] - a[1])[0]?.[0];
+    return { commands: counts, ...(context ? { context } : {}) };
+}
+const sessionsPath = () => join(dirname(configPath()), "sessions.json");
+function isSessionSummary(value) {
+    return (isRecord(value) &&
+        isRecord(value.commands) &&
+        Object.entries(value.commands).every(([name, count]) => COMMANDS.has(name) &&
+            typeof count === "number" &&
+            Number.isSafeInteger(count) &&
+            count > 0) &&
+        (value.context === undefined ||
+            (typeof value.context === "string" && !/[\r\n]/.test(value.context))));
+}
+function readSessions() {
+    try {
+        const parsed = JSON.parse(readFileSync(sessionsPath(), "utf8"));
+        if (isRecord(parsed) && isRecord(parsed.directories))
+            return Object.fromEntries(Object.entries(parsed.directories).filter((entry) => isSessionSummary(entry[1])));
+    }
+    catch {
+        /* Missing or corrupt memory is optional. */
+    }
+    return {};
+}
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return errorCode(error) !== "ESRCH";
+    }
+}
+function lockPid(token) {
+    const pid = Number(token.trim().split(/\s+/, 1)[0]);
+    return Number.isSafeInteger(pid) && pid > 0 ? pid : undefined;
+}
+function errorCode(error) {
+    return error &&
+        typeof error === "object" &&
+        "code" in error &&
+        typeof error.code === "string"
+        ? error.code
+        : undefined;
+}
+async function acquireLock(path) {
+    const lockPath = `${path}.lock`;
+    const deadline = Date.now() + LOCK_WAIT_MS;
+    while (Date.now() < deadline) {
+        try {
+            mkdirSync(lockPath, 0o700);
+            const ownerPath = join(lockPath, `owner-${randomUUID()}`);
+            const token = `${process.pid} ${randomUUID()}\n`;
+            let fd;
+            try {
+                fd = openSync(ownerPath, "wx", 0o600);
+            }
+            catch {
+                rmdirSync(lockPath);
+                return undefined;
+            }
+            try {
+                writeFileSync(fd, token);
+                return { fd, path: ownerPath, token };
+            }
+            catch {
+                closeSync(fd);
+                try {
+                    unlinkSync(ownerPath);
+                    rmdirSync(lockPath);
+                }
+                catch {
+                    /* The lock may already be gone. */
+                }
+                return undefined;
+            }
+        }
+        catch (error) {
+            if (errorCode(error) !== "EEXIST")
+                return undefined;
+            if (reclaimStaleLock(lockPath))
+                continue;
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+    }
+    return undefined;
+}
+function reclaimStaleLock(lockPath) {
+    try {
+        const owners = readdirSync(lockPath);
+        if (owners.length === 0) {
+            if (Date.now() - statSync(lockPath).mtimeMs <= STALE_LOCK_MS)
+                return false;
+            rmdirSync(lockPath);
+            return true;
+        }
+        for (const ownerFile of owners) {
+            const ownerPath = join(lockPath, ownerFile);
+            const info = statSync(ownerPath);
+            const owner = readFileSync(ownerPath, "utf8");
+            const pid = lockPid(owner);
+            if (Date.now() - info.mtimeMs <= STALE_LOCK_MS ||
+                pid === undefined ||
+                processAlive(pid) ||
+                readFileSync(ownerPath, "utf8") !== owner)
+                continue;
+            unlinkSync(ownerPath);
+            rmdirSync(lockPath);
+            return true;
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
+export function releaseSessionLock(lock) {
+    closeSync(lock.fd);
+    try {
+        if (readFileSync(lock.path, "utf8") === lock.token) {
+            unlinkSync(lock.path);
+            rmdirSync(dirname(lock.path));
+        }
+    }
+    catch {
+        /* A successor owns the lock, or it is already gone. */
+    }
+}
+export async function recordSession(directory, summary) {
+    const path = sessionsPath();
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const lock = await acquireLock(path);
+    if (lock === undefined)
+        return false;
+    try {
+        const directories = readSessions();
+        delete directories[directory];
+        directories[directory] = summary;
+        for (const old of Object.keys(directories).slice(0, Math.max(0, Object.keys(directories).length - MAX_DIRECTORIES)))
+            delete directories[old];
+        const temporary = `${path}.${randomUUID()}.tmp`;
+        try {
+            writeFileSync(temporary, `${JSON.stringify({ directories }, null, 2)}\n`, {
+                mode: 0o600,
+            });
+            chmodSync(temporary, 0o600);
+            renameSync(temporary, path);
+        }
+        catch (error) {
+            try {
+                unlinkSync(temporary);
+            }
+            catch {
+                /* No temporary file to remove. */
+            }
+            throw error;
+        }
+        return true;
+    }
+    finally {
+        releaseSessionLock(lock);
+    }
+}
+export function lastSession(directory) {
+    return readSessions()[directory];
+}
+export function sessionText(summary) {
+    const commands = Object.entries(summary.commands)
+        .sort((a, b) => b[1] - a[1])
+        .map(([name, count]) => `${name} ${count}`)
+        .join("; ");
+    return `${commands}${summary.context ? ` - context ${JSON.stringify(summary.context)}` : ""}`;
+}

package/dist/src/version.js

@@ -1,3 +1,3 @@
 // Leaf module: node builtins only, so the bin fast path can answer
 // `--version` without loading the command graph.
-export const VERSION = "0.1.6"; // x-release-please-version
+export const VERSION = "0.1.7"; // x-release-please-version

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "argocd-axi",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Agent-ergonomic Argo CD CLI with opt-in writes - AXI-compliant argocd wrapper with token-efficient TOON output",
   "type": "module",
   "license": "MIT",

package/skills/argocd-axi/SKILL.md

@@ -34,9 +34,11 @@ Run `npx -y argocd-axi auth guide` for offline instructions. A human operator lo
 ## Commands
 
 ```
-commands[25]:
+commands[27]:
   (no command): live overview - context, server, user, apps needing attention with the reason, running operations
   ctx [--context <c>]: current context, server and CLI version, local only (what the session hook prints)
+  context: last session's argocd-axi command summary for this directory
+  context end: record the current Claude Code session summary (SessionEnd hook)
   ctx use <context>: switch the argocd CLI's current context (local config only)
   auth guide [--context <c>]: offline human login and agent token setup instructions
   whoami: user, issuer and groups of the current credential
@@ -59,7 +61,7 @@ commands[25]:
   projects | projects view <p> | projects windows <p>: projects, their rules, and whether sync is allowed now
   appsets | appsets view <name> | appsets generate <file>: ApplicationSets and what a spec would generate
   repos | clusters: repositories and destination clusters with connection status
-  setup hooks: install the SessionStart hook (runs the offline ctx view)
+  setup hooks | status | uninstall: manage the Claude Code SessionEnd memory hook; setup hooks also installs SessionStart hooks
 ```
 
 Run `npx -y argocd-axi --help` for global flags, or `npx -y argocd-axi <command> --help` for per-command usage.