codiedev 0.9.59 → 0.9.61

package/dist/captureSignals.d.ts

@@ -8,12 +8,33 @@ export type CaptureSignals = {
     activeMs: number;
     idleThresholdMs: number;
     skillInvocations: string[];
+    /** How many times each invoked skill ran (each Skill tool call and each
+     *  slash command): three review runs in one session count three. Absent
+     *  from older CLIs, which only sent the unique set above. */
+    skillInvocationCounts?: Array<{
+        skill: string;
+        count: number;
+    }>;
     skillPulls: string[];
     toolCalls: Array<{
         name: string;
         calls: number;
     }>;
+    /** How the harness was launched, raw: Claude Code's "cli" / "sdk-cli",
+     * Codex's "codex:cli" / "codex:exec". Absent when the harness records none. */
+    entrypoints?: string[];
+    /** Claude Code subagent transcripts folded into these signals. */
+    subagents?: {
+        count: number;
+        truncated: boolean;
+    };
+    /** GitHub Copilot subscription usage: premium requests and nano-AIU, from
+     *  the session's latest usage checkpoint or its shutdown. Not dollars. */
+    premiumRequests?: number;
+    nanoAiu?: number;
     truncated: boolean;
 };
 /** Compact diagnostic inputs only: never persist prompts, commands or tool output. */
 export declare function parseCaptureSignals(content: string, source?: string): CaptureSignals;
+/** Add a launch value the hook detected (harnesses that do not record one). */
+export declare function withLaunch(signals: CaptureSignals, launch: string | undefined): CaptureSignals;

package/dist/captureSignals.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CAPTURE_SIGNALS_VERSION = void 0;
 exports.parseCaptureSignals = parseCaptureSignals;
+exports.withLaunch = withLaunch;
 const transcriptModels_1 = require("./transcriptModels");
 exports.CAPTURE_SIGNALS_VERSION = 1;
 const IDLE_MS = 5 * 60_000;
@@ -17,9 +18,12 @@ const skillKey = (value) => typeof value === "string"
 /** Compact diagnostic inputs only: never persist prompts, commands or tool output. */
 function parseCaptureSignals(content, source) {
     const timestamps = new Set();
-    const invocations = new Set(), pulls = new Set();
+    const invocationCounts = new Map();
+    const invocations = new Set(), pulls = new Set(), entrypoints = new Set();
     const tools = new Map(), calls = new Set();
     let parsedRecords = 0, truncated = false;
+    let premiumRequests, nanoAiu;
+    let cursorSubagents;
     const addSkill = (set, value) => {
         const key = skillKey(value);
         if (!key || key.length > 200 || !/^[a-z0-9][a-z0-9_:/.-]*$/i.test(key))
@@ -29,6 +33,8 @@ function parseCaptureSignals(content, source) {
             return;
         }
         set.add(key);
+        if (set === invocations)
+            invocationCounts.set(key, (invocationCounts.get(key) ?? 0) + 1);
     };
     const command = (value) => {
         if (typeof value !== "string")
@@ -66,6 +72,37 @@ function parseCaptureSignals(content, source) {
             continue;
         const e = record;
         parsedRecords++;
+        const entrypoint = (value) => {
+            if (typeof value === "string" &&
+                entrypoints.size < 10 &&
+                /^[a-z0-9][a-z0-9_.:-]{0,39}$/i.test(value))
+                entrypoints.add(value.toLowerCase());
+        };
+        // Claude Code: "cli" at the terminal, "sdk-cli" for `claude -p` / SDK.
+        entrypoint(e.entrypoint);
+        // Codex: session_meta.source is "cli", "vscode", "exec" (`codex exec`),
+        // "mcp", or an object for sub-agents. Namespaced so values never collide.
+        if (e.type === "session_meta" && e.payload) {
+            const src = e.payload.source;
+            entrypoint(typeof src === "string"
+                ? `codex:${src}`
+                : src && typeof src === "object"
+                    ? `codex:${Object.keys(src)[0] ?? "other"}`
+                    : undefined);
+        }
+        if (e.type === "cursor.subagent_summary" && Number.isSafeInteger(e.count) && e.count > 0) {
+            cursorSubagents = { count: e.count, truncated: e.truncated === true };
+        }
+        // GitHub Copilot (normalized): one skill.invoked event per skill run,
+        // whether the user or the agent invoked it.
+        if (e.type === "copilot.skill_invoked")
+            addSkill(invocations, e.skill);
+        if (e.type === "copilot.usage_summary") {
+            if (typeof e.premiumRequests === "number" && e.premiumRequests >= 0)
+                premiumRequests = e.premiumRequests;
+            if (typeof e.nanoAiu === "number" && e.nanoAiu >= 0)
+                nanoAiu = e.nanoAiu;
+        }
         const time = typeof e.timestamp === "string"
             ? Date.parse(e.timestamp)
             : e.info?.time?.created;
@@ -110,10 +147,24 @@ function parseCaptureSignals(content, source) {
         activeMs,
         idleThresholdMs: IDLE_MS,
         skillInvocations: [...invocations].sort(),
+        skillInvocationCounts: [...invocationCounts]
+            .map(([skill, count]) => ({ skill, count }))
+            .sort((a, b) => a.skill.localeCompare(b.skill)),
         skillPulls: [...pulls].sort(),
         toolCalls: [...tools]
             .map(([name, calls]) => ({ name, calls }))
             .sort((a, b) => a.name.localeCompare(b.name)),
+        ...(cursorSubagents ? { subagents: cursorSubagents } : {}),
+        ...(entrypoints.size ? { entrypoints: [...entrypoints].sort() } : {}),
+        ...(premiumRequests !== undefined ? { premiumRequests } : {}),
+        ...(nanoAiu !== undefined ? { nanoAiu } : {}),
         truncated,
     };
 }
+/** Add a launch value the hook detected (harnesses that do not record one). */
+function withLaunch(signals, launch) {
+    if (!launch || !/^[a-z0-9][a-z0-9_.:-]{0,39}$/.test(launch))
+        return signals;
+    const all = new Set([...(signals.entrypoints ?? []), launch]);
+    return all.size > 10 ? signals : { ...signals, entrypoints: [...all].sort() };
+}

package/dist/cli.js

@@ -42,7 +42,8 @@ Codiedev CLI
   someone left off across sessions and providers.
 
 Connect:
-  codiedev connect                       Link Claude Code / Codex / Cursor to your org
+  codiedev connect                       Link Claude Code / Codex / Cursor /
+                                         GitHub Copilot to your org
   codiedev doctor                        Verify your setup after connecting
 
 Harness:
@@ -163,6 +164,7 @@ codiedev connect — link your agent CLI to Codiedev
     - ~/.codex/AGENTS.md instructions    (same, for Codex)
     - ~/.cursor/hooks.json hooks         (session, prompt, security, capture)
     - ~/.cursor/rules/codiedev.mdc       (teaches Cursor the commands)
+    - ~/.copilot/hooks/codiedev.json     (GitHub Copilot: VS Code + CLI capture)
 
   Re-run anytime to swap accounts or refresh the instruction block.
 

package/dist/commands/doctor.js

@@ -45,6 +45,7 @@ const version_1 = require("../version");
 const upgradeNudge_1 = require("../upgradeNudge");
 const captureReadiness_1 = require("../captureReadiness");
 const captureLog_1 = require("../captureLog");
+const copilotInstallation_1 = require("../copilotInstallation");
 const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json");
 const CLAUDE_INSTRUCTIONS_PATH = path.join(os.homedir(), ".claude", "CLAUDE.md");
 const CODEX_HOOKS_PATH = path.join(os.homedir(), ".codex", "hooks.json");
@@ -482,6 +483,16 @@ async function runDoctor(_args) {
             detail: "not installed on this machine",
         });
     }
+    if ((0, utils_1.copilotInstalled)()) {
+        const hooks = (0, copilotInstallation_1.inspectCopilotHooks)();
+        checks.push({ name: "GitHub Copilot capture hooks", status: hooks.status === "pass" ? "pass" : "fail", detail: hooks.detail });
+        checks.push({ name: "GitHub Copilot CLI instructions",
+            status: hasCodiedevInstructions((0, utils_1.copilotInstructionsPath)()) ? "pass" : "fail",
+            detail: hasCodiedevInstructions((0, utils_1.copilotInstructionsPath)()) ? (0, utils_1.copilotInstructionsPath)() : "missing — re-run `codiedev connect`" });
+    }
+    else {
+        checks.push({ name: "GitHub Copilot", status: "warn", detail: "not installed on this machine" });
+    }
     // 8. gh / glab CLIs (optional — only needed for reverse-ticket from a
     // specific PR/MR URL; branch mode works without either).
     checks.push({

package/dist/connect.js

@@ -271,10 +271,12 @@ async function runConnect(args = []) {
     const hasCodex = (0, utils_1.codexInstalled)();
     const hasCursor = (0, utils_1.cursorInstalled)();
     const hasOpenCode = (0, utils_1.openCodeInstalled)();
+    const hasCopilot = (0, utils_1.copilotInstalled)();
     (0, shared_1.recordInstallEvent)(config, { step: "detect", target: "claude-code", ok: hasClaude });
     (0, shared_1.recordInstallEvent)(config, { step: "detect", target: "codex", ok: hasCodex });
     (0, shared_1.recordInstallEvent)(config, { step: "detect", target: "cursor", ok: hasCursor });
     (0, shared_1.recordInstallEvent)(config, { step: "detect", target: "opencode", ok: hasOpenCode });
+    (0, shared_1.recordInstallEvent)(config, { step: "detect", target: "copilot", ok: hasCopilot });
     const installed = [];
     // Machine-readable target keys reported back to the backend via
     // /api/cli/markInstalled so the portal's "Connected" state reflects
@@ -313,6 +315,12 @@ async function runConnect(args = []) {
         runInstall("cursor-hook", utils_1.installCursorHook, "Cursor sessionStart + stop backup + sessionEnd capture hooks (~/.cursor/hooks.json)", "cursor-hook");
         runInstall("cursor-instructions", utils_1.installCursorInstructions, "Cursor agent instructions (~/.cursor/rules/codiedev.mdc)", "cursor-instructions");
     }
+    // One user-level hook file covers both VS Code Copilot Chat and the Copilot
+    // CLI (they share the runtime and its hooks).
+    if (hasCopilot) {
+        runInstall("copilot-hook", () => (0, utils_1.installCopilotHook)(), `GitHub Copilot (VS Code + CLI) sessionStart + agentStop backup + sessionEnd capture hooks (${(0, utils_1.copilotHooksPath)()})`, "copilot-hook");
+        runInstall("copilot-instructions", utils_1.installCopilotInstructions, "GitHub Copilot CLI team artifact instructions", "copilot-instructions");
+    }
     // Always stage the adapter. It is dormant until OpenCode starts, which lets
     // a user connect Claude Code today and install the Codie harness tomorrow
     // without needing a second setup ritual.
@@ -339,7 +347,7 @@ async function runConnect(args = []) {
             });
         }
     }
-    if (!hasClaude && !hasCodex && !hasCursor && !hasOpenCode) {
+    if (!hasClaude && !hasCodex && !hasCursor && !hasOpenCode && !hasCopilot) {
         console.warn("\nNo existing AI client detected; the Codie/OpenCode adapter is ready for a later install.");
         console.warn("If you just installed Claude Code, launch it once (so ~/.claude is created),");
         console.warn("then re-run `npx codiedev connect` to wire up the capture hook.");

package/dist/copilotHooks.d.ts

@@ -0,0 +1,85 @@
+/**
+ * GitHub Copilot: VS Code Copilot Chat's agent and the Copilot CLI run on the
+ * same runtime and write the same session record,
+ * `$COPILOT_HOME/session-state/<sessionId>/events.jsonl` (plus
+ * `workspace.yaml`), and both read user hooks from `$COPILOT_HOME/hooks/*.json`.
+ * Everything Copilot-specific is translated here, at the process boundary, so
+ * the shared capture pipeline only ever sees the Claude-shaped transcript it
+ * already parses.
+ */
+/** `$COPILOT_HOME`, else `~/.copilot` (the runtime honours the same variable). */
+export declare function copilotHome(env?: NodeJS.ProcessEnv, home?: string): string;
+export declare function copilotSessionDir(sessionId: string, home?: string): string | undefined;
+/** sessionEnd carries no transcript path; the session id names the file. */
+export declare function copilotTranscriptPath(sessionId: string | undefined, home?: string): string | undefined;
+export type CopilotWorkspace = {
+    id?: string;
+    cwd?: string;
+    gitRoot?: string;
+    branch?: string;
+    /** "vscode-agent-host" (VS Code Copilot Chat) or "github/cli" (Copilot CLI). */
+    clientName?: string;
+};
+/** workspace.yaml is flat `key: value` lines; no YAML dependency needed. */
+export declare function parseCopilotWorkspace(yaml: string): CopilotWorkspace;
+/** The workspace.yaml beside a transcript (or for a session id); {} if absent. */
+export declare function readCopilotWorkspace(transcriptPathOrDir: string | undefined): CopilotWorkspace;
+export declare const COPILOT_VSCODE_CLIENT = "vscode-agent-host";
+/**
+ * How the session was launched. VS Code names itself in workspace.yaml; the
+ * CLI doesn't record whether it ran headless, so that comes from the process
+ * that launched the hook (`detected`, see launchContext). Unknown stays
+ * unknown rather than guessing "human".
+ */
+export declare function copilotLaunch(clientName: string | undefined, detected: string | undefined): string | undefined;
+/**
+ * Copilot's hook payloads are camelCase (`sessionId`, `transcriptPath`,
+ * `toolName`/`toolArgs`/`toolResult`); preToolUse in the CLI batches calls as
+ * `toolCalls: [{id, name, args}]`. Translate to the shared snake_case shape.
+ * The FIRST tool call fills tool_name/tool_input; `copilotToolCalls` keeps all
+ * of them so security can check each.
+ */
+export declare function normalizeCopilotHookInput<T extends Record<string, unknown>>(input: T, home?: string): T & Record<string, unknown>;
+export type CopilotToolCall = {
+    id?: string;
+    name: string;
+    input: unknown;
+};
+/** Copilot's preToolUse deny output. */
+export declare function copilotPreToolBlockResponse(reason: string): {
+    permissionDecision: "deny";
+    permissionDecisionReason: string;
+};
+/** Only a byte-empty record is safe to discard (same rule as Cursor). */
+export declare function isCopilotTranscriptEmpty(content: string): boolean;
+/** session.shutdown carries the per-model token totals; written after sessionEnd. */
+export declare function hasCopilotShutdown(content: string): boolean;
+export type NormalizedCopilotTranscript = {
+    /** Claude-shaped JSONL for the shared parsers and the upload. */
+    content: string;
+    /** Fleet-mode sub-agents run inside this file (subagent.started). */
+    subagents: {
+        count: number;
+        truncated: boolean;
+    };
+    /** True once session.shutdown (token totals) has been written. */
+    final: boolean;
+};
+/**
+ * events.jsonl → Claude-shaped JSONL:
+ *   session.start          → system record (cwd, branch, entrypoint for VS Code)
+ *   user.message           → user text
+ *   assistant.message      → assistant text + tool_use blocks (model on every call)
+ *   tool.execution_complete→ user tool_result (git output feeds branch/sha joins)
+ *   skill.invoked          → copilot.skill_invoked (one skill run)
+ *   session.shutdown       → copilot.usage per model (tokens, sub-agents
+ *                            included; requests counted from the assistant
+ *                            calls, so 0 here) + copilot.usage_summary
+ *   session.usage_checkpoint → copilot.usage_summary (premium requests and
+ *                            nano-AIU so far; superseded by shutdown)
+ *   subagent.started       → counted as a fleet sub-agent
+ * Hooks, permissions, system prompts and checkpoints are dropped.
+ */
+export declare function normalizeCopilotTranscript(raw: string, opts?: {
+    clientName?: string;
+}): NormalizedCopilotTranscript;