oh-my-copilot 5.6.2 → 5.7.0

package/dist/tools/host-smoke-tool.d.ts

@@ -0,0 +1,34 @@
+/**
+ * host_smoke MCP tool
+ *
+ * Runs the headless Copilot CLI smoke check (`omg smoke copilot`) against a
+ * plugin root and returns the SmokeReport as JSON. Tier 0 makes no model call;
+ * tier 1 spends one premium request; tier 2 drives SDK scenarios (about one
+ * premium request each) and is free only with `scenarios: []` (static checks).
+ *
+ * This tool is also reachable from inside Copilot through the plugin's own `t`
+ * MCP server, so it is fenced (the `omg smoke copilot` CLI is not):
+ * - `pluginRoot` must be the package root this server runs from (compared by
+ *   realpath) unless OMC_SMOKE_ALLOW_ANY_ROOT=1;
+ * - tier 1 (a live, billed session) and tier 2 with any scenario need
+ *   OMC_SMOKE_ALLOW_LIVE=1; tier 2 with `scenarios: []` is free and ungated.
+ *
+ * The smoke library is loaded lazily so listing tools never pays its import cost.
+ */
+import { z } from 'zod';
+import type { ToolDefinition } from './types.js';
+export declare const SMOKE_ALLOW_LIVE_ENV = "OMC_SMOKE_ALLOW_LIVE";
+export declare const SMOKE_ALLOW_ANY_ROOT_ENV = "OMC_SMOKE_ALLOW_ANY_ROOT";
+declare const hostSmokeSchema: {
+    tier: z.ZodOptional<z.ZodNumber>;
+    scenarios: z.ZodOptional<z.ZodArray<z.ZodEnum<["smoke", "guardrail", "skill", "delegate", "all"]>, "many">>;
+    pluginRoot: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    maxCredits: z.ZodOptional<z.ZodNumber>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    keepHome: z.ZodOptional<z.ZodBoolean>;
+    delegate: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const hostSmokeTool: ToolDefinition<typeof hostSmokeSchema>;
+export {};
+//# sourceMappingURL=host-smoke-tool.d.ts.map

package/dist/tools/host-smoke-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-smoke-tool.d.ts","sourceRoot":"","sources":["../../src/tools/host-smoke-tool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,eAAO,MAAM,oBAAoB,yBAAyB,CAAC;AAC3D,eAAO,MAAM,wBAAwB,6BAA6B,CAAC;AAMnE,QAAA,MAAM,eAAe;;;;;;;;;CA4CpB,CAAC;AAYF,eAAO,MAAM,aAAa,EAAE,cAAc,CAAC,OAAO,eAAe,CA0DhE,CAAC"}

package/dist/tools/host-smoke-tool.js

@@ -0,0 +1,133 @@
+/**
+ * host_smoke MCP tool
+ *
+ * Runs the headless Copilot CLI smoke check (`omg smoke copilot`) against a
+ * plugin root and returns the SmokeReport as JSON. Tier 0 makes no model call;
+ * tier 1 spends one premium request; tier 2 drives SDK scenarios (about one
+ * premium request each) and is free only with `scenarios: []` (static checks).
+ *
+ * This tool is also reachable from inside Copilot through the plugin's own `t`
+ * MCP server, so it is fenced (the `omg smoke copilot` CLI is not):
+ * - `pluginRoot` must be the package root this server runs from (compared by
+ *   realpath) unless OMC_SMOKE_ALLOW_ANY_ROOT=1;
+ * - tier 1 (a live, billed session) and tier 2 with any scenario need
+ *   OMC_SMOKE_ALLOW_LIVE=1; tier 2 with `scenarios: []` is free and ungated.
+ *
+ * The smoke library is loaded lazily so listing tools never pays its import cost.
+ */
+import { realpathSync } from 'fs';
+import { resolve } from 'path';
+import { z } from 'zod';
+import { TOOL_CATEGORIES } from '../constants/names.js';
+export const SMOKE_ALLOW_LIVE_ENV = 'OMC_SMOKE_ALLOW_LIVE';
+export const SMOKE_ALLOW_ANY_ROOT_ENV = 'OMC_SMOKE_ALLOW_ANY_ROOT';
+/** Tier 2 scenario names (mirrors the CLI's `--scenario`); `all` expands to the four. */
+const SCENARIO_NAMES = ['smoke', 'guardrail', 'skill', 'delegate'];
+const hostSmokeSchema = {
+    tier: z
+        .number()
+        .int()
+        .min(0)
+        .max(2)
+        .optional()
+        .describe('0 = load check, no model call (default). 1 = tier 0 plus one live session with the prompt on stdin '
+        + '(one premium request). 2 = tier 0 plus @github/copilot-sdk static checks plus scenarios. '
+        + 'Tier 1 and tier 2 with scenarios require OMC_SMOKE_ALLOW_LIVE=1 in the MCP server env.'),
+    scenarios: z
+        .array(z.enum([...SCENARIO_NAMES, 'all']))
+        .optional()
+        .describe('Tier 2 only: scenarios to run (smoke, guardrail, skill, delegate, or all). Default smoke+guardrail '
+        + '(~2 premium requests, 1 per scenario). [] = SDK static checks only, no model call, no opt-in needed.'),
+    pluginRoot: z
+        .string()
+        .optional()
+        .describe('Plugin root to load with --plugin-dir. Defaults to, and must equal, the running package root unless OMC_SMOKE_ALLOW_ANY_ROOT=1.'),
+    model: z.string().optional().describe('Tiers 1-2: model id (default: tier 1 lets the CLI auto-pick; tier 2 a cheap listed model, else auto).'),
+    maxCredits: z
+        .number()
+        .int()
+        .min(30)
+        .optional()
+        .describe('Tiers 1-2: AI credit cap (default and CLI minimum 30). Tier 2 also aborts a scenario and skips the rest once the run passes it.'),
+    timeoutMs: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe('Timeout in ms per subprocess at tier 0 (default 60000), for the session at tier 1 (default 180000), per scenario at tier 2 (default 120000, then abort); the MCP check is fixed at 10 s.'),
+    keepHome: z
+        .boolean()
+        .optional()
+        .describe('Keep the throwaway COPILOT_HOME and project dir for debugging; paths are returned in artifacts.'),
+    delegate: z
+        .boolean()
+        .optional()
+        .describe('Tier 1 only: ask for one delegation to oh-my-copilot:architect to exercise subagent.selected.'),
+};
+function canonical(p) {
+    let out = resolve(p);
+    try {
+        out = realpathSync.native(out);
+    }
+    catch { /* missing: compare the resolved form */ }
+    return process.platform === 'win32' ? out.toLowerCase() : out;
+}
+function errorResult(text) {
+    return { content: [{ type: 'text', text }], isError: true };
+}
+export const hostSmokeTool = {
+    name: 'host_smoke',
+    description: 'Run the headless Copilot CLI smoke check against a plugin root (same as `omg smoke copilot`). ' +
+        'Tier 0 verifies the plugin loads (manifest, hooks, plugin/skill list, MCP tools) without a model call; ' +
+        'tier 1 adds one live session (one premium request, needs OMC_SMOKE_ALLOW_LIVE=1); ' +
+        'tier 2 adds @github/copilot-sdk static checks (free with scenarios: []) and SDK scenarios (need OMC_SMOKE_ALLOW_LIVE=1). ' +
+        'Returns the SmokeReport JSON; isError when any check fails.',
+    category: TOOL_CATEGORIES.SMOKE,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    schema: hostSmokeSchema,
+    handler: async (args) => {
+        try {
+            const tier = (args.tier ?? 0);
+            if (args.scenarios !== undefined && tier !== 2) {
+                return errorResult('host_smoke: scenarios apply to tier 2 only.');
+            }
+            const scenarios = args.scenarios === undefined
+                ? undefined
+                : [...new Set(args.scenarios.flatMap((s) => (s === 'all' ? [...SCENARIO_NAMES] : [s])))];
+            // Tier 2 without `scenarios` runs the library default (smoke, guardrail): live.
+            const live = tier === 1 || (tier === 2 && (scenarios === undefined || scenarios.length > 0));
+            if (live && process.env[SMOKE_ALLOW_LIVE_ENV] !== '1') {
+                return errorResult(`host_smoke: tier ${tier}${tier === 2 ? ' with scenarios' : ''} runs live, billed Copilot sessions and is disabled for MCP callers. `
+                    + `Set ${SMOKE_ALLOW_LIVE_ENV}=1 in the MCP server env, pass scenarios: [] for the free tier 2 static checks, `
+                    + `or run \`omg smoke copilot --tier ${tier}\` from a shell.`);
+            }
+            const { runCopilotSmoke, resolvePackageRoot } = await import('../smoke/copilot-smoke.js');
+            if (args.pluginRoot !== undefined && process.env[SMOKE_ALLOW_ANY_ROOT_ENV] !== '1') {
+                const packageRoot = resolvePackageRoot();
+                if (!packageRoot || canonical(args.pluginRoot) !== canonical(packageRoot)) {
+                    return errorResult(`host_smoke: pluginRoot ${JSON.stringify(args.pluginRoot)} is not this server's package root `
+                        + `(${packageRoot ?? 'unresolved'}). Set ${SMOKE_ALLOW_ANY_ROOT_ENV}=1 to smoke another root.`);
+                }
+            }
+            const opts = {
+                tier,
+                ...(args.pluginRoot !== undefined ? { pluginRoot: args.pluginRoot } : {}),
+                ...(args.model !== undefined ? { model: args.model } : {}),
+                ...(args.maxCredits !== undefined ? { maxCredits: args.maxCredits } : {}),
+                ...(args.timeoutMs !== undefined ? { timeoutMs: args.timeoutMs } : {}),
+                ...(args.keepHome !== undefined ? { keepHome: args.keepHome } : {}),
+                ...(args.delegate !== undefined ? { delegate: args.delegate } : {}),
+                ...(scenarios !== undefined ? { scenarios } : {}),
+            };
+            const report = await runCopilotSmoke(opts);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(report, null, 2) }],
+                ...(report.ok ? {} : { isError: true }),
+            };
+        }
+        catch (error) {
+            return errorResult(`host_smoke failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    },
+};
+//# sourceMappingURL=host-smoke-tool.js.map

package/dist/tools/host-smoke-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-smoke-tool.js","sourceRoot":"","sources":["../../src/tools/host-smoke-tool.ts"],"names":[],"mappings":"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"}

package/docs/CLAUDE.md

@@ -1,5 +1,5 @@
 <!-- OMC:START -->
-<!-- OMC:VERSION:5.6.2 -->
+<!-- OMC:VERSION:5.7.0 -->
 
 # oh-my-copilot - Intelligent Multi-Agent Orchestration
 

package/docs/DEVELOPERS.md

@@ -1,3 +1,104 @@
 # Developers
 
 See [CONTRIBUTING.md](../CONTRIBUTING.md) for the full developer guide.
+
+## Headless smoke against a local build
+
+`omg smoke copilot` loads a plugin root into the real GitHub Copilot CLI inside a throwaway `COPILOT_HOME` and reports one line per check. It replaces the manual "install the plugin and open Copilot" step. Build first: the MCP check spawns `dist/mcp/standalone-server.js`.
+
+```bash
+npm run build
+omg smoke copilot --tier 0        # free: no model call
+omg smoke copilot --tier 1        # costs one premium request
+```
+
+### The two tiers
+
+- **Tier 0 is a free load check.** It verifies the manifest and version, the generated hooks and agents, `plugin list` and `skill list` as Copilot sees them, and the MCP server's tool count. Run it after every generator change.
+- **Tier 1 adds one live session with the prompt on stdin.** It asserts the session exits cleanly, the session events log parses, our hooks fired, the plugin and MCP server loaded, and the hooks wrote state under `.omg/` in a temp project. Each run is one premium request capped by `--max-credits` (default 30, which is Copilot's minimum).
+
+**Model.** `--model` is optional. Without it Copilot auto-selects a model; 1.0.91 picked `mai-code-1.1-flash`. Explicit ids may be rejected as unavailable for your account, and the `session.exit` detail then says to omit `--model`.
+
+**Auth.** Tier 1 copies only the login identity from your real Copilot config, so a normal `copilot /login` is enough. Do not export a token for it. `GH_TOKEN` and `GITHUB_TOKEN` take precedence over a stored login, and a `gh` token is not entitled to Copilot models, so the smoke drops both from the session when it found a login. `COPILOT_GITHUB_TOKEN` is always passed through. Without a stored login, as in CI, all three pass through and one of them must hold a Copilot-entitled token.
+
+**Hooks fail closed.** The session runs with `OMC_HOOK_FAIL_CLOSED=1`, so a crashing hook shows up as a failed `hooks.*` check instead of being swallowed by the hook adapter. The `hooks.adapter_errors` check also fails on any `[omg-hook]` error line in the debug log, session stderr, events, or stdout. With `OMC_HOOK_FAIL_CLOSED=1` a hook timeout in `scripts/run.cjs` also exits `124` instead of failing open.
+
+**Sandbox.** The session denies `t(host_smoke)` so the model cannot recurse into the smoke, and passes `--disable-builtin-mcps`. The default prompt also denies `shell` and `write`; `--delegate` keeps them because the hand-off is a tool call. The env drops `OMC_*`, Claude Code host markers, `NODE_OPTIONS`, `COPILOT_MODEL`, `COPILOT_OFFLINE`, and `COPILOT_PROVIDER_*` before spawning Copilot.
+
+Use `--keep-home` to keep the temp homes and project for debugging, and `--json` for the full report. The report's `artifacts.listHome` is the tier 0 home and `artifacts.copilotHome` is the tier 1 session home. `--json` always prints a report; a bad option yields `ok: false` with one `cli.error` check. Exit code `2` means the `copilot` binary was not found and nothing else failed. The binary resolves from PATH first, then `COPILOT_CLI_PATH`, then the WinGet install location on Windows. Set `COPILOT_CLI_PATH` when it is not on PATH; a `copilot` on PATH still wins.
+
+### From vitest
+
+`npm run test:live` runs `tests/live/copilot-smoke.test.ts`. Tier 0 runs whenever the binary resolves and skips otherwise. Tier 1 runs only with `OMC_LIVE_SMOKE=1`, so it never spends a request by accident. The free tier 2 static checks run whenever the binary and `@github/copilot-sdk` resolve. The tier 2 default scenarios run only with `OMC_LIVE_SMOKE=2`. The default `npm test` run and CI exclude `tests/live/**`.
+
+### From Claude Code (MCP tool `host_smoke`)
+
+The standalone MCP server exposes the same check as `host_smoke`. Register the local build once:
+
+```bash
+claude mcp add omg-dev -- node C:/Code/OMC/dist/mcp/standalone-server.js
+```
+
+Then ask Claude Code to call `host_smoke` with `{ "tier": 0 }`. It returns the report JSON and sets `isError` when any check fails. Rebuild after source changes, because the server runs from `dist/`.
+
+The tool is also reachable from inside Copilot through the plugin's own MCP server, so it is fenced. Two env vars on the MCP server lift the fences:
+
+- **`OMC_SMOKE_ALLOW_LIVE=1`** allows `{ "tier": 1 }` and tier 2 with scenarios. Without it the tool refuses both, because they are billed sessions. `{ "tier": 2, "scenarios": [] }` runs the free SDK static checks and needs no opt-in.
+- **`OMC_SMOKE_ALLOW_ANY_ROOT=1`** allows a `pluginRoot` other than the package root the server runs from. Paths are compared after resolving symlinks.
+
+```bash
+claude mcp add omg-dev -e OMC_SMOKE_ALLOW_LIVE=1 -- node C:/Code/OMC/dist/mcp/standalone-server.js
+```
+
+The `omg smoke copilot` CLI has no such gate.
+
+### Tier 2 — SDK scenarios
+
+Tier 2 drives Copilot through `@github/copilot-sdk` instead of `copilot -p`. The SDK sees the full event stream and the runtime's own plugin, skill, agent, and MCP lists, so it can assert behaviour that tier 1 cannot: a guardrail deny, a skill invocation, a delegation.
+
+```bash
+npm i -g @github/copilot-sdk --omit=optional --ignore-scripts
+omg smoke copilot --sdk-static                # free: SDK static checks, no model call
+omg smoke copilot --tier 2                    # smoke + guardrail, about 2 premium requests (1 per scenario)
+omg smoke copilot --tier 2 --scenario all     # adds skill + delegate
+```
+
+**Install.** The SDK is an optional peer dependency, so `npm i -g oh-my-copilot` never installs it. Install it next to `omg` with the command above. `--ignore-scripts` is required on Windows with `--omit=optional`, because koffi's install script otherwise falls back to a source build that needs CMake. Without the SDK every `sdk.*` check fails with that install hint and the run exits `2`.
+
+**Bundled runtime.** A global install can still pull the SDK's platform runtime, about 128 MB, despite `--omit=optional`. It lands nested at `<npm root -g>/@github/copilot-sdk/node_modules/@github/copilot-sdk-<platform>`. Delete that folder if it appears; tier 2 never uses it. The lean alternative is a project-local install in the plugin root, which the spike measured at 11 MB:
+
+```bash
+npm i --no-save --omit=optional --ignore-scripts @github/copilot-sdk
+```
+
+**Installed-exe policy.** Tier 2 always connects the SDK to the installed `copilot` binary, resolved exactly as for tier 0 and 1. It never uses the SDK's bundled runtime, because the installed CLI is what users run and plugin loading differs between the two. `sdk.runtime` checks that the runtime reports the tier 0 binary version and protocol 3 or later.
+
+**Scenarios.** `smoke` and `guardrail` are the default; `--scenario` takes a comma-separated list or `all`. Each scenario runs in its own session in a temp git repo with an isolated `COPILOT_HOME`, a per-scenario timeout, and its full event stream kept as `artifacts.events.<name>`. `scn.<name>.cost` reports premium requests and credits.
+
+**Credit cap.** `--max-credits` (default and minimum 30) caps the whole tier 2 run. The runtime gets `--max-ai-credits` with the same value; the headless runtime accepts and validates the flag (CLI 1.0.91), but whether it enforces it on SDK sessions is unverified. The smoke therefore enforces the cap itself: it sums `assistant.usage` credits per scenario, aborts the scenario that passes what is left (`scn.<name>.exit` and `.cost` fail), and reports the remaining scenarios as `skipped: credit cap reached`.
+
+**No billing from unit tests.** Under vitest (`VITEST` or `NODE_ENV=test`) `runCopilotSmoke` refuses any run that would call a model, with one `cli.guard` check and no spawn, unless `OMC_LIVE_SMOKE=1` (tier 1) or `OMC_LIVE_SMOKE=2` (tier 2 scenarios) is set or the test injects the seam that would bill (`deps.spawn` at tier 1, `deps.loadSdk` at tier 2). `--sdk-static` is never refused.
+
+**Runtime teardown.** After `client.stop()` the smoke checks whether the runtime pid is still alive and kills its process tree. A scenario that does not go idle even after `abort()` marks the runtime wedged: the remaining scenarios are skipped and the tree is killed before `stop()`, so hook and MCP children are not orphaned. On POSIX the SDK does not start the runtime as a process-group leader, so the kill reaches the runtime itself but not always its children.
+
+**Quirks verified on SDK 1.0.16 with Copilot CLI 1.0.91.**
+
+- **`sessionStart` is lazy.** It fires after the first `userPromptSubmitted`, not at session creation.
+- **`sessionEnd` fires after every turn.** In SDK and headless mode OMC's SessionEnd hooks therefore run per turn, also on abort.
+- **Skill name differs from its path.** `skill.invoked` reports the frontmatter name, such as `omc-plan`, not `oh-my-copilot:plan`. Assert on `path` ending in `skills/plan/SKILL.md` and on `pluginName`.
+- **MCP tool names are `<server>-<tool>`.** Excluding `t-host_smoke` works; `t:host_smoke` and `t(host_smoke)` match nothing in `excludedTools`. The smoke takes the server name from the first `.mcp.json` key, and `sdk.tools_excluded` proves the exclusion against `session.rpc.tools.getCurrentMetadata` without a model call.
+- **Env is per client, not per session.** Hook processes inherit the runtime's env, so a scenario that needs a different env, such as `OMC_GIT_GUARDRAILS=1`, needs its own client.
+- **Hook stderr is only in the debug log.** It appears in `COPILOT_HOME/logs/*.log` as `[hook stderr]` lines and only at log level `debug`. `scn.<name>.adapter_errors` reads that log for `[omg-hook]` lines from the adapter and `[run.cjs]` lines from the hook runner, such as a hook timeout. Lines are attributed to a scenario by their timestamp, so a late SessionEnd line lands in the scenario that caused it.
+- **Windows npm shim.** The SDK spawns the runtime without a shell, so a `copilot.cmd` or `.ps1` shim is resolved to the `.js` or `.exe` it launches. If that fails, every `sdk.*` and `scn.*` check fails with a hint to pass `--copilot-bin`.
+
+### Copilot CLI facts the smoke relies on
+
+These were verified against Copilot CLI 1.0.91.
+
+- **Free load checks.** `copilot --plugin-dir <root> plugin list --json` and `copilot --plugin-dir <root> skill list --json` make no model call and reflect `--plugin-dir`.
+- **A bad `--plugin-dir` only warns.** The command still succeeds and `plugin list` returns `[]`, so assert on the exact entry, never on the exit code.
+- **Manifest locations.** Copilot accepts the plugin manifest at `plugin.json`, `.github/plugin/plugin.json`, or `.claude-plugin/plugin.json` under the root.
+- **`plugin install` takes no local path.** Use `--plugin-dir` to load a working tree.
+- **An isolated `COPILOT_HOME` needs a token.** A fresh home has no stored login, so pass a token through the environment for any model call.
+- **Trusted folders are camelCase.** Write `trustedFolders` in `$COPILOT_HOME/config.json` so `-p` runs in the temp project without a trust prompt.
+- **No `installed_plugins.json`.** Installed plugins live under `~/.copilot/installed-plugins/`.

package/docs/HOOKS.md

@@ -86,7 +86,7 @@ The adapter fails **open** on a hook's internal error. Copilot treats a PreToolU
 | Variable | Effect |
 |---|---|
 | `OMC_HOOK_EVENT` | Set by `copilot/hooks.json`; activates the adapter. |
-| `OMC_HOOK_FAIL_CLOSED=1` | Keep the hook's original non-zero exit code (fail closed). |
+| `OMC_HOOK_FAIL_CLOSED=1` | Keep the hook's original non-zero exit code (fail closed). The hook runner `scripts/run.cjs` also exits `124` when a hook times out, instead of the default fail-open `0`, and its stderr line says `exiting fail-closed (124)`. |
 | `OMC_HOOK_STRICT=1` | A hook target that is missing or not a file exits 1 instead of 0 plus a stderr line. |
 | `OMC_DEBUG_HOOKS` | Log adapter decisions, such as a dropped `updatedInput`, to stderr. |
 

package/docs/MIGRATION.md

@@ -8,6 +8,7 @@ This guide covers all migration paths for oh-my-copilot. Find your current versi
 
 - [Unreleased: Team Instance Ownership](#unreleased-team-instance-ownership)
 - [Unreleased: Cancellation Scope](#unreleased-cancellation-scope)
+- [v5.6.2 → v5.7.0: Smoke Harness](#v562--v570-smoke-harness)
 - [v5.6.1 → v5.6.2: Postinstall Hook](#v561--v562-postinstall-hook)
 - [v5.5.0 → v5.6.1: Fork Upgrade Guide](#v550--v561-fork-upgrade-guide)
 - [v5.1.0 → v5.5.0: Fork Upgrade Guide](#v510--v550-fork-upgrade-guide)
@@ -122,6 +123,76 @@ locations and descendants of system temp/OS roots are never used as roots.
 
 ---
 
+## v5.6.2 → v5.7.0: Smoke Harness
+
+Fork **v5.7.0** adds a headless smoke harness and ports upstream
+oh-my-claudecode `dev` 486b85bbb..bcaceb136. There is nothing to migrate: no
+config, command or skill is renamed or removed.
+
+- Update with `npm install -g oh-my-copilot@5.7.0` or
+  `copilot plugin update oh-my-copilot@omc`.
+
+### Adopting `omg smoke copilot` and `host_smoke`
+
+Build first (`npm run build`); the MCP check spawns
+`dist/mcp/standalone-server.js`.
+
+| Tier | Command | Cost |
+| --- | --- | --- |
+| 0 | `omg smoke copilot --tier 0` | Free, no model call |
+| 1 | `omg smoke copilot --tier 1` | 1 premium request |
+| 2 static | `omg smoke copilot --sdk-static` | Free, no model call |
+| 2 | `omg smoke copilot --tier 2 [--scenario all]` | About 1 premium request per scenario; the default `smoke` + `guardrail` costs about 2 |
+
+`--max-credits` (default and minimum 30) caps a run. The CLI has no opt-in
+gate. The MCP tool `host_smoke` has two, set as env vars on the MCP server:
+
+- **`OMC_SMOKE_ALLOW_LIVE=1`** allows `{ "tier": 1 }` and tier 2 with
+  scenarios. `{ "tier": 2, "scenarios": [] }` runs the free static checks
+  without it.
+- **`OMC_SMOKE_ALLOW_ANY_ROOT=1`** allows a `pluginRoot` other than the
+  server's own package root.
+
+`OMC_DISABLE_TOOLS=smoke` hides the tool. From vitest, `npm run test:live`
+runs tier 0 whenever the `copilot` binary resolves. It runs tier 1 only with
+`OMC_LIVE_SMOKE=1` and the tier 2 scenarios only with `OMC_LIVE_SMOKE=2`.
+Details are in
+[DEVELOPERS.md](DEVELOPERS.md#headless-smoke-against-a-local-build).
+
+### Optional SDK for tier 2
+
+`@github/copilot-sdk` is an optional peer dependency; installing
+oh-my-copilot never pulls it in. Install it only if you want tier 2:
+
+```bash
+npm i -g @github/copilot-sdk --omit=optional --ignore-scripts
+```
+
+`--ignore-scripts` avoids a CMake source build on Windows. If a global
+install still adds the SDK's bundled platform runtime (about 128 MB), delete
+it; tier 2 always uses the installed `copilot` binary.
+
+### `OMC_HOOK_FAIL_CLOSED=1`
+
+The variable is opt-in and unset by default. Without it, the Copilot hook
+adapter turns a hook's non-zero exit into `0` plus one `[omg-hook]` stderr
+line, and a hook that times out in `scripts/run.cjs` exits `0`, so hooks fail
+open. With `OMC_HOOK_FAIL_CLOSED=1` the adapter keeps the hook's exit code,
+and a hook timeout in `scripts/run.cjs` exits `124`. Exit `2` on
+PermissionRequest means deny in both modes. The smoke harness sets the
+variable for its own sessions.
+
+### Team env passthrough on POSIX (#4236)
+
+`OMC_TEAM_WORKER_ENV_PASSTHROUGH` keeps the same configuration. On POSIX tmux
+teams its values are no longer inlined into the worker pane's command line.
+They are written to a private `0600` file in a `0700` directory, which the
+pane's `/bin/sh` sources and removes before it execs the login shell. Nothing
+changes for you, but the values no longer appear in `ps` output or tmux
+`pane_start_command`.
+
+---
+
 ## v5.6.1 → v5.6.2: Postinstall Hook
 
 Fork **v5.6.2** ports upstream oh-my-claudecode `dev` 4280efb1f..486b85bbb.

package/docs/REFERENCE.md

@@ -2,7 +2,7 @@
 
 Complete reference for oh-my-copilot. For quick start, see the main [README.md](../README.md).
 
-For v5.6.2, the plugin ships 20 agents, 61 skills, 21 command files, and one configured MCP server exposing exactly 55 tools.
+For v5.7.0, the plugin ships 20 agents, 61 skills, 21 command files, and one configured MCP server exposing exactly 56 tools.
 
 ---
 
@@ -732,6 +732,47 @@ omg lookout scan --strict   # exit 1 when review is recommended (for scripts)
 - `--json` emits the full report; exit codes: `0` for every successful non-strict scan and for strict scans without a review-recommended verdict, `1` for `--strict` with a review-recommended verdict, `2` for a usage/scan error
 - High-risk verdicts pair with approval gates and checkpoints: `omg graph run --approval-mode remote --checkpoint`, `omg checkpoint create`
 
+### `omg smoke copilot`
+
+Headless smoke check of a plugin root against the real GitHub Copilot CLI, in a throwaway `COPILOT_HOME`. Use it on a local build before opening a PR or tagging a release.
+
+```bash
+omg smoke copilot                     # tier 0: load check, no model call
+omg smoke copilot --tier 1            # tier 0 + one live session, prompt on stdin (one premium request)
+omg smoke copilot --plugin-root /path/to/oh-my-copilot --json
+omg smoke copilot --tier 1 --keep-home --delegate --model <id> --max-credits 30 --timeout 180000
+omg smoke copilot --sdk-static        # tier 2 SDK static checks only, no model call
+omg smoke copilot --tier 2            # tier 2 default scenarios smoke,guardrail (~2 premium requests, 1 per scenario)
+omg smoke copilot --tier 2 --scenario skill,delegate   # or --scenario all
+```
+
+- **Tier 0** checks: `plugin.manifest`, `plugin.hooks`, `copilot.binary`, `copilot.plugin_list`, `copilot.skill_list`, `copilot.agents`, `mcp.list_tools`. `mcp.list_tools` spawns `dist/mcp/standalone-server.js`, so run `npm run build` first.
+- **Tier 1** adds `session.exit`, `session.events`, `hooks.*` (including `hooks.adapter_errors`), `plugins.loaded`, `mcp.server_loaded`, `state.written`, and with `--delegate` `subagent.selected`. Hooks run with `OMC_HOOK_FAIL_CLOSED=1`; a `hook.end` without `success: true` fails its check, and `hooks.adapter_errors` fails on any `[omg-hook]` error line.
+- **Tier 2** drives the installed `copilot` binary through the optional peer `@github/copilot-sdk` (install it with `npm i -g @github/copilot-sdk --omit=optional --ignore-scripts`; a nested `@github/copilot-sdk-<platform>` runtime package is unused and can be deleted, see [DEVELOPERS.md](./DEVELOPERS.md#tier-2--sdk-scenarios)). It runs the tier 0 checks, then the SDK static checks `sdk.available`, `sdk.runtime`, `sdk.plugins`, `sdk.skills`, `sdk.agents`, `sdk.mcp`, `sdk.tools_excluded` (our `<server>-host_smoke` tool is absent from the session's tool list), then the chosen scenarios. It does not run the tier 1 `-p` session. `--sdk-static` runs no scenario and makes no model call.
+- **Tier 2 scenarios** yield checks prefixed `scn.<name>.`. Each one also gets `scn.<name>.exit`, `scn.<name>.adapter_errors` (fails on any `[omg-hook]` or `[run.cjs]` hook stderr line, such as a hook timeout), and `scn.<name>.cost`. Each scenario costs about one premium request, so the default run costs about two.
+
+| Scenario | Prompt exercises | Key checks |
+|---|---|---|
+| `smoke` (default) | a plain reply, no tools | `scn.smoke.reply`, `scn.smoke.hooks`, `scn.smoke.no_tools` |
+| `guardrail` (default) | `git push --force` with `OMC_GIT_GUARDRAILS=1` against a bare remote | `scn.guardrail.denied`, `scn.guardrail.no_push`, `scn.guardrail.hooks` |
+| `skill` | `/oh-my-copilot:plan` | `scn.skill.invoked` |
+| `delegate` | a hand-off to `oh-my-copilot:architect` | `scn.delegate.selected`, `scn.delegate.hooks`, `scn.delegate.completed` |
+
+- **Tier 2 report** adds `sdk` (SDK version, runtime version, protocol version), `cost` (premium requests and credits summed over scenarios), and `artifacts.events` with one events JSONL path per scenario. Human output groups the `sdk.*` checks and each scenario's `scn.<name>.*` checks under a heading.
+- **Model:** `--model` is optional. Copilot auto-selects when it is omitted (1.0.91 picked `mai-code-1.1-flash`); explicit ids may be rejected as unavailable.
+- **Auth:** tier 1 reuses the login identity from your Copilot config, so `copilot /login` is enough. When a login is found the session drops `GH_TOKEN` and `GITHUB_TOKEN`, which would otherwise shadow it. `COPILOT_GITHUB_TOKEN` always passes through, and without a stored login (CI) all three do.
+- `--max-credits` must be at least 30, the Copilot CLI minimum. At tier 1 it is passed as `--max-ai-credits`. At tier 2 it caps the whole run: the runtime also gets `--max-ai-credits`, a scenario whose credits pass what is left is aborted, and the remaining scenarios fail with `skipped: credit cap reached`. `--model` applies to tiers 1 and 2. `--timeout` applies per subprocess at tier 0, to the session at tier 1, and per scenario at tier 2; the MCP check is fixed at 10 s.
+- Under a test runner (`VITEST` or `NODE_ENV=test`), a run that would call a model is refused with one `cli.guard` check before anything is spawned, unless `OMC_LIVE_SMOKE=1` (tier 1) or `OMC_LIVE_SMOKE=2` (tier 2 scenarios) is set.
+- Exit codes: `0` all checks pass, `1` a check failed or an option was invalid, `2` skipped because the `copilot` binary or, at tier 2, `@github/copilot-sdk` did not resolve and nothing else failed. Resolution order is PATH, then `COPILOT_CLI_PATH`, then the WinGet install location on Windows, so a `copilot` on PATH wins over `COPILOT_CLI_PATH`.
+- `--json` always prints a `SmokeReport`, with one `cli.error` check for invalid options. `--keep-home` keeps the temp homes and project and reports them as `artifacts.listHome` (tier 0) and `artifacts.copilotHome` (tier 1).
+- The same check is exposed as the MCP tool `host_smoke` (arguments `tier`, `pluginRoot`, `model`, `maxCredits`, `timeoutMs`, `keepHome`, `delegate`, `scenarios`). It returns the report JSON with `isError` set when any check fails. Tier 1 and tier 2 with scenarios need `OMC_SMOKE_ALLOW_LIVE=1` in the MCP server env; tier 2 with `scenarios: []` is free and needs no opt-in, and a `pluginRoot` other than the server's own package root needs `OMC_SMOKE_ALLOW_ANY_ROOT=1`. To call it from Claude Code against a local build, register the standalone server:
+
+```bash
+claude mcp add omg-dev -- node C:/Code/OMC/dist/mcp/standalone-server.js
+```
+
+`OMC_DISABLE_TOOLS=smoke` hides `host_smoke`. See [DEVELOPERS.md](./DEVELOPERS.md#headless-smoke-against-a-local-build) for the developer workflow.
+
 ### Graph approval gates (remote approvals)
 
 Graph runtime `human-approval` nodes support two gate styles via `omg graph run`:

package/docs/TOOLS.md

@@ -2,7 +2,7 @@
 
 > OMC provides MCP tools for state management, code intelligence, and data analysis.
 
-At v5.3.0, the configured MCP server exposes exactly 55 tools.
+The configured MCP server exposes exactly 56 tools.
 
 Unlike skills that users invoke directly, tools are used internally by agents during task execution.
 
@@ -19,6 +19,7 @@ Unlike skills that users invoke directly, tools are used internally by agents du
 - [Shared Memory](#shared-memory) — Cross-agent shared memory for team coordination
 - [Skills](#skills) — Internal skill management tools
 - [Deepinit Manifest](#deepinit-manifest) — Incremental AGENTS.md regeneration manifest
+- [Host Smoke](#host-smoke) — Headless Copilot CLI smoke check of a plugin root
 
 ---
 
@@ -768,3 +769,33 @@ deepinit_manifest(action="check")
 ```
 
 Used internally by the `deepinit` skill (`/oh-my-copilot:deepinit`) to enable incremental AGENTS.md regeneration instead of full re-scans.
+
+---
+
+## Host Smoke
+
+Runs the same check as `omg smoke copilot` against a plugin root and returns the `SmokeReport` JSON. The result has `isError` set when any check fails. `OMC_DISABLE_TOOLS=smoke` hides it.
+
+### Tool
+
+#### `host_smoke`
+
+| Argument     | Type    | Meaning                                                                 |
+| ------------ | ------- | ----------------------------------------------------------------------- |
+| `tier`       | 0, 1 or 2 | `0` load check without a model call (default); `1` adds one live session, one premium request; `2` adds `@github/copilot-sdk` static checks and SDK scenarios. Tier 1 needs `OMC_SMOKE_ALLOW_LIVE=1` in the server env |
+| `scenarios`  | string[] | Tier 2 only: `smoke`, `guardrail`, `skill`, `delegate`, or `all`. Omitted runs `smoke` and `guardrail`, about two premium requests (one per scenario), and needs `OMC_SMOKE_ALLOW_LIVE=1`. `[]` runs the SDK static checks only, with no model call and no opt-in |
+| `pluginRoot` | string  | Plugin root passed to `--plugin-dir`; defaults to the package root. Any other root needs `OMC_SMOKE_ALLOW_ANY_ROOT=1` |
+| `model`      | string  | Tiers 1-2 model id; omitted means Copilot auto-selects at tier 1 and a cheap listed model, else auto, at tier 2 |
+| `maxCredits` | integer | Tiers 1-2 AI credit cap, default and minimum 30. Tier 1 passes `--max-ai-credits`; tier 2 also aborts a scenario and skips the rest once the run passes it |
+| `timeoutMs`  | integer | Per subprocess at tier 0 (default 60000), for the session at tier 1 (default 180000), or per scenario at tier 2 (default 120000); the MCP check is fixed at 10 s |
+| `keepHome`   | boolean | Keep the temp `COPILOT_HOME` and project; paths are in `artifacts`      |
+| `delegate`   | boolean | Tier 1: also exercise one delegation to `oh-my-copilot:architect`       |
+
+```
+host_smoke(tier=0)
+host_smoke(tier=2, scenarios=[])   # SDK static checks, free
+```
+
+Tier 2 needs the optional peer `@github/copilot-sdk` next to the package. Without it the `sdk.*` checks fail with an install hint and the report is marked `skipped`.
+
+See [DEVELOPERS.md](./DEVELOPERS.md#headless-smoke-against-a-local-build) for the check list and how to register a local build in Claude Code.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-copilot",
-  "version": "5.6.2",
+  "version": "5.7.0",
   "description": "Multi-agent orchestration system for Copilot CLI - Inspired by oh-my-opencode",
   "type": "module",
   "main": "dist/index.js",
@@ -74,6 +74,7 @@
     "test:ui": "vitest --ui --exclude \"tests/perf/**\"",
     "test:run": "vitest run --exclude \"tests/perf/**\"",
     "test:coverage": "vitest run --coverage --exclude \"tests/perf/**\"",
+    "test:live": "vitest run --config vitest.live.config.ts",
     "prepack": "npm run build",
     "lint": "eslint src",
     "format": "prettier --write src/**/*.ts",
@@ -131,6 +132,14 @@
     "typescript-eslint": "^8.53.0",
     "vitest": "^4.1.11"
   },
+  "peerDependencies": {
+    "@github/copilot-sdk": "^1.0.16"
+  },
+  "peerDependenciesMeta": {
+    "@github/copilot-sdk": {
+      "optional": true
+    }
+  },
   "engines": {
     "node": "20.x || 22.x || 23.x || 24.x || 25.x || 26.x"
   },
@@ -159,5 +168,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "dff284086ef69f7bd488ba13346e66a90180d671"
+  "gitHead": "58eabdf4c1eb5c63573ce906adb8bfc4fa87ac78"
 }

package/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-copilot",
-  "version": "5.6.2",
+  "version": "5.7.0",
   "description": "Multi-agent orchestration system for GitHub Copilot CLI",
   "author": {
     "name": "oh-my-copilot contributors"

package/scripts/dev/repro-state-lock.mjs

@@ -1,4 +1,4 @@
-// Repro for upstream issue #4146: mutual exclusion of the owner-file fallback in
+// Repro for issue #4146: mutual exclusion of the owner-file fallback in
 // scripts/lib/state-lock.mjs (owner releases/exits during a reclaimer's liveness
 // probe; the reclaimer must not quarantine a live replacement owner).
 //

package/scripts/lib/atomic-write.mjs

@@ -137,9 +137,11 @@ function readEmergencyJournal(path) {
   } catch { return null; }
 }
 
+// BigInt ids: NTFS file IDs exceed 2^53 once the MFT sequence number reaches
+// 32, and a Number ino rounds distinct files onto the same value.
 function fileIdentity(path) {
   try {
-    const stat = statSync(path);
+    const stat = statSync(path, { bigint: true });
     return { dev: stat.dev, ino: stat.ino };
   } catch { return null; }
 }
@@ -157,7 +159,7 @@ function sameFileIdentity(a, b) {
   // On Windows, lstat returns dev=0, so skip dev comparison when on Windows
   // unless both are non-zero (indicating a real comparison is possible)
   const isWindows = process.platform === 'win32';
-  if (isWindows && (a.dev === 0 || b.dev === 0)) {
+  if (isWindows && (a.dev === 0n || b.dev === 0n)) {
     return true; // Skip dev comparison on Windows when either is 0
   }