codiedev 0.9.60 → 0.9.62

package/dist/captureSignals.d.ts

@@ -28,6 +28,10 @@ export type CaptureSignals = {
         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. */

package/dist/captureSignals.js

@@ -22,6 +22,8 @@ function parseCaptureSignals(content, source) {
     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))
@@ -88,6 +90,19 @@ function parseCaptureSignals(content, source) {
                     ? `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;
@@ -139,7 +154,10 @@ function parseCaptureSignals(content, source) {
         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,
     };
 }

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;