@dezycro-ai/agent-plugin 2.1.2 → 2.3.0

package/dist/schemas/anthropic.d.ts

@@ -0,0 +1,119 @@
+/**
+ * schemas/anthropic.ts — Anthropic Messages API wire shapes + protocol constants.
+ *
+ * Minimal and permissive: we model only the fields the gateway actually reads,
+ * each with a generic `[k: string]: unknown` tail so unknown fields survive a
+ * round-trip untouched.
+ *
+ * The protocol's string literals (event types, block types, delta types, stop
+ * reasons) are named constants below — code compares against `StreamEventType.*`
+ * etc. rather than bare strings, and the event/block interfaces pin their
+ * discriminant to the same constant so the two can't drift. The streaming events
+ * are a discriminated union on `type`, so `switch (event.type)` narrows the
+ * payload with no casts.
+ */
+export declare const StreamEventType: {
+    readonly MessageStart: "message_start";
+    readonly ContentBlockStart: "content_block_start";
+    readonly ContentBlockDelta: "content_block_delta";
+    readonly ContentBlockStop: "content_block_stop";
+    readonly MessageDelta: "message_delta";
+    readonly MessageStop: "message_stop";
+};
+export declare const MessageRole: {
+    readonly User: "user";
+    readonly Assistant: "assistant";
+    readonly System: "system";
+};
+export declare const ContentBlockType: {
+    readonly Text: "text";
+    readonly ToolUse: "tool_use";
+};
+export declare const DeltaType: {
+    readonly Text: "text_delta";
+    readonly InputJson: "input_json_delta";
+};
+export declare const StopReason: {
+    readonly ToolUse: "tool_use";
+    readonly EndTurn: "end_turn";
+};
+export interface AnthropicTextBlock {
+    type: typeof ContentBlockType.Text;
+    text: string;
+    cache_control?: unknown;
+}
+export interface AnthropicToolUseBlock {
+    type: typeof ContentBlockType.ToolUse;
+    id?: string;
+    name?: string;
+    input?: Record<string, unknown>;
+}
+/** A content block we don't specifically model — forwarded as-is. */
+export interface AnthropicUnknownBlock {
+    type: string;
+    [k: string]: unknown;
+}
+export type AnthropicContentBlock = AnthropicTextBlock | AnthropicToolUseBlock | AnthropicUnknownBlock;
+export interface AnthropicMessage {
+    role: string;
+    content: string | AnthropicContentBlock[];
+}
+export interface AnthropicSystemBlock {
+    type: string;
+    text?: string;
+    cache_control?: unknown;
+    [k: string]: unknown;
+}
+export interface AnthropicBody {
+    model?: string;
+    stream?: boolean;
+    system?: string | AnthropicSystemBlock[];
+    tools?: unknown[];
+    messages?: AnthropicMessage[];
+    input?: unknown;
+    stop_reason?: string | null;
+    content?: AnthropicContentBlock[];
+    [k: string]: unknown;
+}
+export interface TextDelta {
+    type: typeof DeltaType.Text;
+    text: string;
+}
+export interface InputJsonDelta {
+    type: typeof DeltaType.InputJson;
+    partial_json: string;
+}
+export type BlockDelta = TextDelta | InputJsonDelta | {
+    type: string;
+    [k: string]: unknown;
+};
+export interface MessageStartEvent {
+    type: typeof StreamEventType.MessageStart;
+    message?: unknown;
+}
+export interface ContentBlockStartEvent {
+    type: typeof StreamEventType.ContentBlockStart;
+    index: number;
+    content_block: AnthropicContentBlock;
+}
+export interface ContentBlockDeltaEvent {
+    type: typeof StreamEventType.ContentBlockDelta;
+    index: number;
+    delta: BlockDelta;
+}
+export interface ContentBlockStopEvent {
+    type: typeof StreamEventType.ContentBlockStop;
+    index: number;
+}
+export interface MessageDeltaEvent {
+    type: typeof StreamEventType.MessageDelta;
+    delta: {
+        stop_reason?: string | null;
+        [k: string]: unknown;
+    };
+    [k: string]: unknown;
+}
+export interface MessageStopEvent {
+    type: typeof StreamEventType.MessageStop;
+}
+export type StreamEvent = MessageStartEvent | ContentBlockStartEvent | ContentBlockDeltaEvent | ContentBlockStopEvent | MessageDeltaEvent | MessageStopEvent;

package/dist/schemas/anthropic.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * schemas/anthropic.ts — Anthropic Messages API wire shapes + protocol constants.
+ *
+ * Minimal and permissive: we model only the fields the gateway actually reads,
+ * each with a generic `[k: string]: unknown` tail so unknown fields survive a
+ * round-trip untouched.
+ *
+ * The protocol's string literals (event types, block types, delta types, stop
+ * reasons) are named constants below — code compares against `StreamEventType.*`
+ * etc. rather than bare strings, and the event/block interfaces pin their
+ * discriminant to the same constant so the two can't drift. The streaming events
+ * are a discriminated union on `type`, so `switch (event.type)` narrows the
+ * payload with no casts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StopReason = exports.DeltaType = exports.ContentBlockType = exports.MessageRole = exports.StreamEventType = void 0;
+/* ── protocol constants (the wire's magic strings, named) ──────────────────── */
+exports.StreamEventType = {
+    MessageStart: 'message_start',
+    ContentBlockStart: 'content_block_start',
+    ContentBlockDelta: 'content_block_delta',
+    ContentBlockStop: 'content_block_stop',
+    MessageDelta: 'message_delta',
+    MessageStop: 'message_stop',
+};
+exports.MessageRole = {
+    User: 'user',
+    Assistant: 'assistant',
+    System: 'system',
+};
+exports.ContentBlockType = {
+    Text: 'text',
+    ToolUse: 'tool_use',
+};
+exports.DeltaType = {
+    Text: 'text_delta',
+    InputJson: 'input_json_delta',
+};
+exports.StopReason = {
+    ToolUse: 'tool_use',
+    EndTurn: 'end_turn',
+};

package/dist/schemas/dezycro.d.ts

@@ -0,0 +1,19 @@
+/**
+ * schemas/dezycro.ts — Dezycro domain constants the gateway reasons about.
+ *
+ * These name the concrete tool/field/status values the default gating policy
+ * matches against, so the policy reads as data, not magic strings.
+ */
+/** Dezycro MCP tool name fragments matched by gating rules. */
+export declare const ToolName: {
+    readonly UpdateTask: "update_task";
+};
+/** Tool input field names referenced by gating rules. */
+export declare const ToolInputField: {
+    readonly Status: "status";
+};
+/** Workbook task statuses (the terminal ones the gate guards). */
+export declare const TaskStatus: {
+    readonly Done: "DONE";
+    readonly Pushed: "PUSHED";
+};

package/dist/schemas/dezycro.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * schemas/dezycro.ts — Dezycro domain constants the gateway reasons about.
+ *
+ * These name the concrete tool/field/status values the default gating policy
+ * matches against, so the policy reads as data, not magic strings.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskStatus = exports.ToolInputField = exports.ToolName = void 0;
+/** Dezycro MCP tool name fragments matched by gating rules. */
+exports.ToolName = {
+    UpdateTask: 'update_task',
+};
+/** Tool input field names referenced by gating rules. */
+exports.ToolInputField = {
+    Status: 'status',
+};
+/** Workbook task statuses (the terminal ones the gate guards). */
+exports.TaskStatus = {
+    Done: 'DONE',
+    Pushed: 'PUSHED',
+};

package/dist/schemas/gateway.d.ts

@@ -0,0 +1,40 @@
+/**
+ * schemas/gateway.ts — gateway runtime types.
+ *
+ * The gateway is a local interception proxy between a coding agent and its model
+ * provider: it delivers skills/slash-commands and enforcement regardless of
+ * native support, via request injection (cache-safe) and response tool gating.
+ */
+/** Model providers the gateway can adapt (value + type share the name). */
+export declare const Provider: {
+    readonly Anthropic: "anthropic";
+    readonly OpenAI: "openai";
+};
+export type Provider = (typeof Provider)[keyof typeof Provider];
+/** Agents the launcher knows how to point at the gateway. */
+export declare const Agent: {
+    readonly Claude: "claude";
+    readonly Codex: "codex";
+};
+/** Local control-plane paths (never forwarded upstream). Shared by proxy + launcher. */
+export declare const ControlPath: {
+    readonly Health: "/__dz/health";
+    readonly Stop: "/__dz/stop";
+};
+/** Response content-types the gate special-cases. */
+export declare const ContentType: {
+    readonly EventStream: "text/event-stream";
+    readonly Json: "application/json";
+};
+/** trigger (e.g. "/dezycro:verify") -> instruction text injected on match. */
+export interface SkillRegistry {
+    [trigger: string]: string;
+}
+export interface GatewayConfig {
+    port: number;
+    inject: boolean;
+    gate: boolean;
+    capture: boolean;
+    /** path to the launch repo's .dezycro/companion-state.json for state-aware gating. */
+    stateFile?: string | null;
+}

package/dist/schemas/gateway.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * schemas/gateway.ts — gateway runtime types.
+ *
+ * The gateway is a local interception proxy between a coding agent and its model
+ * provider: it delivers skills/slash-commands and enforcement regardless of
+ * native support, via request injection (cache-safe) and response tool gating.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentType = exports.ControlPath = exports.Agent = exports.Provider = void 0;
+/** Model providers the gateway can adapt (value + type share the name). */
+exports.Provider = {
+    Anthropic: 'anthropic',
+    OpenAI: 'openai',
+};
+/** Agents the launcher knows how to point at the gateway. */
+exports.Agent = {
+    Claude: 'claude',
+    Codex: 'codex',
+};
+/** Local control-plane paths (never forwarded upstream). Shared by proxy + launcher. */
+exports.ControlPath = {
+    Health: '/__dz/health',
+    Stop: '/__dz/stop',
+};
+/** Response content-types the gate special-cases. */
+exports.ContentType = {
+    EventStream: 'text/event-stream',
+    Json: 'application/json',
+};

package/dist/schemas/gating.d.ts

@@ -0,0 +1,32 @@
+/**
+ * schemas/gating.ts — the tool-call gating policy model.
+ *
+ * A policy is a list of rules. A rule matches a tool_use by name (substring) and
+ * optionally by an input field value, then requires a set of workflow-state
+ * predicates to ALL hold; if any fails, the call is blocked with a reason.
+ */
+import type { CompanionState } from '../hooks/types';
+/** Named, live-state predicates a rule can require (see STATE_PREDICATES). */
+export declare const PredicateName: {
+    readonly SpecPublished: "specPublished";
+    readonly VerifiedRecently: "verifiedRecently";
+};
+export type StatePredicateName = (typeof PredicateName)[keyof typeof PredicateName];
+export type StatePredicate = (s: CompanionState | null | undefined) => boolean;
+export interface GateRule {
+    /** Match a tool_use whose name contains this substring. */
+    nameIncludes: string;
+    /** Optionally also require an input field to be one of these values. */
+    inputField?: string;
+    inputValues?: Array<string | number>;
+    /** State predicates that must ALL hold to ALLOW; otherwise block. */
+    requireAll?: StatePredicateName[];
+    reason?: string;
+}
+export interface GatePolicy {
+    rules: GateRule[];
+}
+export interface GateDecision {
+    block: boolean;
+    reason: string | null;
+}

package/dist/schemas/gating.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * schemas/gating.ts — the tool-call gating policy model.
+ *
+ * A policy is a list of rules. A rule matches a tool_use by name (substring) and
+ * optionally by an input field value, then requires a set of workflow-state
+ * predicates to ALL hold; if any fails, the call is blocked with a reason.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PredicateName = void 0;
+/** Named, live-state predicates a rule can require (see STATE_PREDICATES). */
+exports.PredicateName = {
+    SpecPublished: 'specPublished',
+    VerifiedRecently: 'verifiedRecently',
+};

package/dist/schemas/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * schemas/ — formalized models for the gateway, in one place.
+ *
+ *   anthropic.ts — provider wire shapes (request body, content blocks, SSE events)
+ *   gating.ts    — tool-call gating policy/rules/decisions
+ *   gateway.ts   — gateway runtime config + provider/skill types
+ *
+ * Import from '../schemas' (this barrel) rather than the individual files.
+ */
+export * from './anthropic';
+export * from './dezycro';
+export * from './gating';
+export * from './gateway';
+export type { CompanionState } from '../hooks/types';

package/dist/schemas/index.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * schemas/ — formalized models for the gateway, in one place.
+ *
+ *   anthropic.ts — provider wire shapes (request body, content blocks, SSE events)
+ *   gating.ts    — tool-call gating policy/rules/decisions
+ *   gateway.ts   — gateway runtime config + provider/skill types
+ *
+ * Import from '../schemas' (this barrel) rather than the individual files.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./anthropic"), exports);
+__exportStar(require("./dezycro"), exports);
+__exportStar(require("./gating"), exports);
+__exportStar(require("./gateway"), exports);

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@dezycro-ai/agent-plugin",
-  "version": "2.1.2",
+  "version": "2.3.0",
   "description": "Official Dezycro plugin for AI coding agents (Claude Code today, more to come) — reverse-engineer your codebase into features, PRDs, TRDs, and live verification.",
   "bin": {
-    "dezycro-setup": "./setup.js",
-    "dezycro-resolve-auth": "./bin/resolve-auth.js"
+    "dezycro": "./dist/cli/dezycro.js"
   },
   "keywords": [
     "dezycro",
@@ -29,22 +28,31 @@
     "hooks/**/*",
     "prompts/**/*",
     "skills/**/*",
-    "bin/**/*",
-    "install.js",
-    "setup.js",
     "README.md",
-    "PERSONAS.md",
-    "LICENSE"
+    "PERSONAS.md"
   ],
   "scripts": {
     "build": "tsc",
-    "prepare": "[ -d src ] && tsc || true",
-    "prepublishOnly": "npm run build",
-    "postinstall": "node install.js",
-    "setup": "node setup.js"
+    "bundle": "node scripts/bundle.mjs",
+    "lint": "eslint src/gateway src/schemas src/cli",
+    "lint:fix": "eslint src/gateway src/schemas src/cli --fix",
+    "format": "prettier --write \"src/{gateway,schemas,cli}/**/*.ts\"",
+    "format:check": "prettier --check \"src/{gateway,schemas,cli}/**/*.ts\"",
+    "prepare": "[ -d src ] && tsc && node scripts/bundle.mjs || true",
+    "prepublishOnly": "npm run build && npm run bundle",
+    "postinstall": "[ -f dist/cli/install.js ] && node dist/cli/install.js || true",
+    "setup": "node dist/cli/dezycro.js setup",
+    "test": "npm run lint && npm run build && node --test test/*.test.js"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",
-    "typescript": "^5.6.0"
+    "esbuild": "^0.28.0",
+    "eslint": "^10.4.1",
+    "prettier": "^3.8.3",
+    "typescript": "^5.6.0",
+    "typescript-eslint": "^8.60.1"
+  },
+  "dependencies": {
+    "tslog": "^4.10.2"
   }
 }

package/skills/verify/SKILL.md

@@ -90,21 +90,23 @@ If no `setup` command, skip this step. If there's a `healthCheck` but no `setup`
 
 2. Call `pull_verifier(featureId, platform)` via MCP (using the `pull_verifier` tool with `featureId` and `platform` parameters).
 
-3. If the tool returns an error indicating no binary exists:
-   - Check generation status by calling `generation_status(workspaceId, featureId)` via MCP.
-   - If generation is **in progress** (status is not IDLE/COMPLETE/FAILED):
-     - Tell the user: "JEP generation in progress — waiting for binary..."
-     - Poll `generation_status` every 15 seconds, up to 20 times (5 minutes).
-     - Show a brief status update every poll: "Still generating... (<status>)"
-     - Once status is COMPLETE, retry `pull_verifier`.
-     - If status is FAILED or timeout reached, tell the user:
-       > JEP generation failed or timed out. Check the generation logs or run `/dezycro:publish-spec` to retry.
-     - Then stop.
-   - If generation is **IDLE** (never started):
-     - Tell the user:
-       > No verifier binary available. The feature needs an API spec first.
-       > Run `/dezycro:publish-spec` to upload your spec and trigger JEP generation.
-     - Then stop.
+3. If the tool returns an error indicating no binary exists, the verifier is still generating or compiling. Don't busy-poll — block on the *pushed* event with the bundled generic CLI, filtered to the verifier event type. It server-side long-polls `/inbox/wait`, prints the first matching event as JSON the moment it lands, and exits 0 (event) / 5 (timeout) / 2 (error). It reads the token/workspace/active-feature from `.dezycro/` itself:
+
+   ```bash
+   dezycro await-event --event-types VERIFIER_STATUS_UPDATE --feature "$FEATURE" --timeout 600
+   echo "exit=$?"
+   ```
+
+   Act on the exit code, then (on 0) on the event's `payload`:
+
+   - **exit 5 (TIMEOUT)**: no event within the budget. Do one final direct `pull_verifier`; if it still returns no binary, tell the user verification did not run and to check the generation pipeline. Do NOT claim verification ran.
+   - **exit 2 (ERROR / not configured)**: couldn't reach the endpoint, or no feature is bound. Show the line; fall back to a single `pull_verifier` retry before giving up.
+   - **exit 0**: an event was printed as JSON. Read its `payload` and act:
+     - **`payload.status` = `READY`**: the binary is ready. Re-run `pull_verifier(featureId, platform)` and continue to Step 4.4.
+     - **`payload.status` = `EMPTY`, or `payload.stage` = `JEP_GENERATION`**: generation produced no executable checks (the journeys aren't checkable API outcomes). STOP. Quote `payload.message`/`payload.reasonCode`, tell the user to fix the spec, and re-run `/dezycro:publish-spec`. Do NOT claim verification ran.
+     - **`payload.status` = `FAILED`** (typically `payload.stage` = `COMPILE`): the verifier build failed. STOP. Quote the message and offer to retry via the `retry_verifier_build` MCP tool, then re-run this wait. Do NOT claim verification ran.
+
+   (If the agent is doing other work instead of waiting here, it doesn't need this command — the Dezycro companion injects the same event as a background nudge when it lands; read its `payload` the same way.)
 
 4. From the response, extract `downloadUrl`, `contentHash`, and any CLI usage hints.
 

package/LICENSE

@@ -1,18 +0,0 @@
-Copyright (c) 2026 Dezycro Inc. All rights reserved.
-
-This software and its source code are proprietary and confidential to
-Dezycro Inc. No part of this software may be reproduced, distributed,
-modified, sublicensed, or used to create derivative works, in whole or
-in part, without the prior written permission of Dezycro Inc.
-
-The software is provided to authorized users solely for use with the
-Dezycro platform under the terms of a separate agreement. Unauthorized
-copying, distribution, reverse engineering, decompilation, or
-disassembly is strictly prohibited.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT.
-IN NO EVENT SHALL DEZYCRO INC. BE LIABLE FOR ANY CLAIM, DAMAGES, OR
-OTHER LIABILITY ARISING FROM, OUT OF, OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/bin/resolve-auth.js

@@ -1,112 +0,0 @@
-#!/usr/bin/env node
-// Resolve .dezycro/auth.local.json into a shell-safe env fragment suitable for
-// `env $(dezycro-resolve-auth) <verifier-binary> ...`.
-//
-// Schema is documented in claude-plugin/PERSONAS.md:
-//   personas.<name>.envVar  → env var name to set (e.g. AUTH_ADMIN1)
-//   personas.<name>.config  → JSON payload (the value of the env var)
-//   secrets.<NAME>          → secret pool used by ${NAME} substitution
-//     values may be:
-//       inline literal
-//       "!file:<path>"    — read file contents (~ expanded)
-//       "!env:<NAME>"     — read from process env
-//       "!cmd:<command>"  — run via /bin/sh -c, use trimmed stdout
-//
-// Missing file → exit 0 with empty output (not an error: CI/dev may export
-// the AUTH_* vars directly). Per-persona failures emit a stderr warning and
-// skip that persona so unrelated tests can still run.
-//
-// Usage:
-//   dezycro-resolve-auth [<path>]            # defaults to .dezycro/auth.local.json
-//   eval "$(dezycro-resolve-auth)"; ./verifier run ...
-//
-// Output is newline-separated `export KEY='value'` statements, where single
-// quotes inside the value are POSIX-escaped. MUST be consumed via `eval`
-// (or `source /dev/stdin <<< "$(...)"`), NOT via `env $(…)` — the latter
-// skips shell quote-stripping and hands the binary a value that still starts
-// with a literal `'`, producing `invalid character '\'' looking for …` parse
-// errors from the Go JSON decoder.
-
-const fs = require("fs");
-const os = require("os");
-const { execSync } = require("child_process");
-
-function shQuote(s) {
-  return "'" + String(s).replace(/'/g, "'\\''") + "'";
-}
-
-function resolveSecret(raw) {
-  if (typeof raw !== "string") return raw;
-  if (raw.startsWith("!file:")) {
-    const p = raw.slice(6).replace(/^~(?=\/|$)/, os.homedir());
-    return fs.readFileSync(p, "utf8").replace(/\s+$/, "");
-  }
-  if (raw.startsWith("!env:")) {
-    const name = raw.slice(5);
-    if (!(name in process.env)) throw new Error(`env var not set: ${name}`);
-    return process.env[name];
-  }
-  if (raw.startsWith("!cmd:")) {
-    const cmd = raw.slice(5);
-    const out = execSync(cmd, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
-    const trimmed = out.replace(/\s+$/, "");
-    if (!trimmed) throw new Error(`empty stdout from: ${cmd}`);
-    return trimmed;
-  }
-  return raw;
-}
-
-function substitute(obj, secrets) {
-  if (typeof obj === "string") {
-    return obj.replace(/\$\{([A-Z0-9_]+)\}/g, (_, name) => {
-      if (!(name in secrets)) throw new Error(`\${${name}} not in secrets`);
-      return secrets[name];
-    });
-  }
-  if (Array.isArray(obj)) return obj.map((x) => substitute(x, secrets));
-  if (obj && typeof obj === "object") {
-    const out = {};
-    for (const [k, v] of Object.entries(obj)) out[k] = substitute(v, secrets);
-    return out;
-  }
-  return obj;
-}
-
-function main() {
-  const authPath = process.argv[2] || ".dezycro/auth.local.json";
-  if (!fs.existsSync(authPath)) {
-    process.stderr.write(`[dezycro-resolve-auth] no auth file at ${authPath}; emitting nothing\n`);
-    return;
-  }
-  let doc;
-  try {
-    doc = JSON.parse(fs.readFileSync(authPath, "utf8"));
-  } catch (e) {
-    process.stderr.write(`[dezycro-resolve-auth] parse error in ${authPath}: ${e.message}\n`);
-    process.exit(1);
-  }
-
-  const secrets = {};
-  for (const [k, v] of Object.entries(doc.secrets || {})) {
-    try {
-      secrets[k] = resolveSecret(v);
-    } catch (e) {
-      process.stderr.write(`[dezycro-resolve-auth] warning: secret ${k}: ${e.message}\n`);
-    }
-  }
-
-  const lines = [];
-  for (const [name, p] of Object.entries(doc.personas || {})) {
-    if (!p || !p.envVar) continue;
-    try {
-      const cfg = substitute(p.config || {}, secrets);
-      lines.push(`export ${p.envVar}=${shQuote(JSON.stringify(cfg))}`);
-    } catch (e) {
-      process.stderr.write(`[dezycro-resolve-auth] warning: persona '${name}' skipped: ${e.message}\n`);
-    }
-  }
-
-  if (lines.length) process.stdout.write(lines.join("\n") + "\n");
-}
-
-main();