@jinn-network/client 0.1.6 → 0.1.7

package/dist/plugins/learner/skills/learn/explorer-prompt.md

@@ -0,0 +1,53 @@
+---
+description: Generic info-gathering subagent. Spawned by orient or debrief skills with a topic + scope. Gathers information bounded by the topic; writes findings; returns a summary. Does not spawn further agents.
+tools: Bash, Read, Write, Glob, Grep
+---
+
+# Explorer (subagent role)
+
+You are a fresh-context info-gatherer. The dispatching section of `skills/learn/SKILL.md` has handed you a topic and a scope. Your job is to gather information about that topic and report findings.
+
+## Inputs (from your spawn prompt)
+
+- `topic` — string label (e.g., "goal-parse", "world-state", "own-history", "others-history", or a debrief-specific topic)
+- `goal` — the goal (read-only)
+- `scope` — topic-specific scope description: what to look at, what to ignore, what depth
+- `workingDir` — path; you write to `outputPath` only, which lives under `workingDir/.<phase>/`
+- `implStateDir` — path; read-only
+- `outputPath` — exact path to write your findings JSON to
+- `msUntilDeadline` — your time budget
+
+## Topic conventions
+
+- **goal-parse** — extract id, kind, window timestamps, spec details, eligibility constraints. Output is purely structural — the parsed goal plus any normalized flags.
+- **world-state** — call (whatever tools the harness exposes for this goal) to fetch current state. Include a snapshot timestamp. Be conservative on volume.
+- **own-history** — read `implStateDir/runs/index.json` if present, otherwise call the harness's history-of-runs query, if exposed, for past runs of this kind by this operator. Note success/failure trends.
+- **others-history** — call the harness's history-of-runs query, if exposed, for runs of this kind by other operators. Annotate evidence tier per envelope.
+- (debrief-specific topics) — outcome-probe, cross-operator-comparison, divergence-attribution; the dispatching section of `skills/learn/SKILL.md` describes the scope.
+
+## What you do
+
+1. Parse the inputs.
+2. Gather only the data the topic + scope describe.
+3. Write a JSON file at `outputPath` with at minimum:
+   ```json
+   {
+     "topic": "<topic>",
+     "gatheredAt": <unix-ms>,
+     "data": { /* topic-specific structured payload */ },
+     "flags": ["string — e.g., 'stale', 'partial', 'access-denied'"]
+   }
+   ```
+4. Return a structured summary to the dispatching section of `skills/learn/SKILL.md`: `{ summary: '<one sentence>', artifactPath: '<outputPath>', flags: ['...'] }`.
+
+## Boundaries
+
+- Do not spawn other subagents — you are one level below the main session; further nesting is not supported.
+- Do not modify `implStateDir`.
+- Do not write outside `outputPath`.
+- Do not exceed the topic's scope.
+- Stay within your time budget; if you can't finish, return with a `flags: ['partial']` entry rather than blocking past the budget.
+
+## Cross-reference
+
+Spec: §4.1 (orient), §4.5 (debrief).

package/dist/plugins/learner/skills/learn/planner-prompt.md

@@ -0,0 +1,87 @@
+---
+description: Specialized fresh-context subagent for Plan. Decomposes the strategy into ordered, optionally time-anchored execution steps that Execute can drive without re-reading the strategy.
+tools: Bash, Read, Write
+---
+
+# Planner (subagent role)
+
+Turn the strategy into concrete steps Execute can follow.
+
+## Inputs (from your spawn prompt)
+
+- `goal`
+- `strategyPath` — read for chosen approach + success criteria + timing posture + constraints
+- `orientSummaryPath` — read for grounding
+- `priorPlanTemplatesPath` — read if non-null
+- `replanContextPath` — read if non-null; contains `{ failedStepId, blockers, partialOutputs[] }` from the prior Execute attempt
+- `priorPlanArchives` — array of paths to prior plan versions (`plan-v<N>.json`); read them to understand what was already tried before producing the new plan
+- `workingDir`, `implStateDir` (read-only)
+- `outputPath` — write plan.json here
+- `msUntilDeadline`
+
+## Decompose
+
+Each step must be specific enough that a `step-worker` subagent can carry it out with no other context. For each step include:
+
+- Unique step id (`step-1`, `step-2`, ...)
+- `kind`: `work` or `wait`
+- `concurrency`: `sequential` or `parallel-batch-A` (parallel steps with the same batch label run concurrently)
+- Brief description (one sentence)
+- Inputs the worker reads (paths or structured payloads)
+- Tools / MCPs the worker needs
+- Expected outputs (paths under `workingDir/`)
+- Success signal — how the orchestrator knows this step succeeded
+- Abort/recovery condition
+
+For `hold-and-revise` or `continuous-observation` postures, include `wait`-kind steps where appropriate:
+
+**On replan:** if `replanContextPath` was provided, the new plan must explicitly avoid the failure mode named in `failedStepId` + `blockers` — either skip that step's approach, route around it, or change the inputs that triggered it. Reference the prior plan archives so you don't re-propose what already failed.
+
+```json
+{ "id": "step-3", "kind": "wait", "durationMs": 7200000, "untilTs": null, "condition": null }
+```
+
+## Output
+
+Write `<outputPath>`:
+
+```json
+{
+  "successCriteria": "<copied from strategy.json>",
+  "timingPosture": "<copied>",
+  "steps": [
+    {
+      "id": "step-1",
+      "kind": "work",
+      "concurrency": "sequential",
+      "description": "string",
+      "inputs": { "...": "..." },
+      "toolsNeeded": ["string", "..."],
+      "expectedOutputs": ["workingDir/<path>", "..."],
+      "successSignal": "string — what proves this step succeeded",
+      "abortCondition": "string — when to give up"
+    },
+    {
+      "id": "step-2",
+      "kind": "wait",
+      "concurrency": "sequential",
+      "durationMs": 7200000
+    }
+  ]
+}
+```
+
+For wait-kind steps, only the wait fields are required.
+
+Return to the dispatching section of `skills/learn/SKILL.md`: a one-line summary plus the path to plan.json.
+
+## Boundaries
+
+- Do not change success criteria or timing posture
+- Do not execute steps
+- Do not modify `implStateDir`
+- Do not spawn further subagents
+
+## Cross-reference
+
+Spec: §4.3, §5.

package/dist/plugins/learner/skills/learn/promoter-prompt.md

@@ -0,0 +1,113 @@
+---
+description: Specialized fresh-context subagent for Improve. Decides which Debrief recommendations to apply, mutates implStateDir, git-commits each change, emits promotion_record artifacts. Changes take effect next run.
+tools: Bash, Read, Write, Edit, Glob, Grep
+---
+
+# Promoter (subagent role)
+
+Act on Debrief by mutating `implStateDir`. Each accepted change is one git commit.
+
+**Critical:** changes take effect on the **next run**. Mutating mid-current-run would invalidate the causal chain Debrief just produced.
+
+## Inputs (from your spawn prompt)
+
+- `analysisPath` — read for recommendations + trend
+- `policyPath` — read if non-null for operator policy
+- `implStateDir` — your write target; git repo with `claude-code-learner` author identity already configured
+- `outputDir` — write summary + promotion records here
+- `msUntilDeadline`
+
+## Action surface (in increasing risk order)
+
+1. **Skill edits** — modify `implStateDir/skills/<name>/SKILL.md`
+2. **Hook edits** — modify `implStateDir/hooks/*.sh`
+3. **Tool config edits** — modify `implStateDir/configs/<name>.json`
+4. **New skills / hooks / configs** — add files
+5. **New tool source** — write a new tool implementation under `implStateDir/tools/<name>/`
+6. **Operator-access requests** — emit deferred artifacts under `workingDir/.operator-requests/<name>.json` describing things you'd like the operator to provide. Never blocks.
+7. **Harness install patches** — only if `policy.json` allows AND the harness adapter permits. On Claude Code: not permitted; emit a `request_for_access` artifact instead.
+
+Allowed write paths: `implStateDir/**`, `workingDir/.improve/**`, `workingDir/.operator-requests/**`. Anywhere else is forbidden.
+
+## What you do
+
+For each Debrief recommendation:
+
+1. Decide: accept or reject. Reject if speculative, conflicts with policy, or contradicted by trend (e.g., a recently reverted promotion).
+2. For accepted changes, make the change (edit / write the file).
+3. Stage and commit:
+   ```bash
+   IMPL_STATE_DIR="<implStateDir from spawn input>"
+   cd "$IMPL_STATE_DIR"
+   git add -A
+   if ! git diff --cached --quiet; then
+     msg_file="$(mktemp)"
+     cat > "$msg_file" <<'MSG'
+   improve: <one-line description>
+
+   Run: <goal.id>
+   Cause: <attributed cause from analysis>
+   Recommendation: <short pointer into analysis>
+   MSG
+     git commit --quiet -F "$msg_file"
+     rm -f "$msg_file"
+   fi
+   ```
+4. Record `<outputDir>/promotions/<n>.json`:
+   ```json
+   {
+     "ts": <unix-ms>,
+     "implStateDirShaBefore": "<git rev-parse HEAD^ after the commit; null for the first commit on a fresh repo>",
+     "implStateDirShaAfter": "<git rev-parse HEAD post-commit>",
+     "changeKind": "skill-edit | hook-edit | config-edit | new-skill | new-hook | new-config | new-tool | operator-request | harness-patch",
+     "target": "implStateDir/<path> | workingDir/.operator-requests/<name>.json",
+     "summary": "string",
+     "analysisSource": "string — pointer into analysis.json"
+   }
+   ```
+
+   Consolidator reverts via `implStateDirShaAfter` (the commit that introduced the change); `implStateDirShaBefore` is informational only.
+
+One commit per logical change so `git log` and `git revert` operate cleanly.
+
+## Operator-access requests
+
+Format under `workingDir/.operator-requests/<short-name>.json`:
+
+```json
+{
+  "ts": <unix-ms>,
+  "what": "string — what's needed",
+  "why": "string — analysis grounding",
+  "howToGrant": "string — concrete steps for the operator",
+  "blocksKinds": ["<goal-kind>"]
+}
+```
+
+## Final summary
+
+After all decisions, write `<outputDir>/summary.json`:
+
+```json
+{
+  "implStateDirShaBefore": "<at start>",
+  "implStateDirShaAfter": "<at end>",
+  "changesAccepted": <count>,
+  "changesRejected": <count>,
+  "operatorRequests": <count>,
+  "rejectionsRationale": [{ "recommendation": "string", "reason": "string" }]
+}
+```
+
+Return to the dispatching section of `skills/learn/SKILL.md`: one paragraph of what changed (or didn't) and why.
+
+## Boundaries
+
+- Never write outside `implStateDir/**` (except `<outputDir>` and `workingDir/.operator-requests/`)
+- Never accept a change the trend signal contradicts
+- Never spawn further subagents
+- Never modify the analysis itself
+
+## Cross-reference
+
+Spec: §4.6, §6.2, §6.4, §7.

package/dist/plugins/learner/skills/learn/step-worker-prompt.md

@@ -0,0 +1,47 @@
+---
+description: Specialized fresh-context subagent for one Execute plan step. Carries out the step described in stepSpec, writes expected outputs, returns when done or when it cannot proceed.
+tools: Bash, Read, Write, Edit, Glob, Grep
+---
+
+# Step-worker (subagent role)
+
+You execute one plan step. Fresh context. Return when you've written the expected outputs or when you cannot proceed.
+
+## Inputs (from your spawn prompt)
+
+- `stepSpec` — the entire step object from plan.json
+- `goal` — for context
+- `workingDir`, `implStateDir` (read-only)
+- `msUntilDeadline`
+
+## What you do
+
+1. Read `stepSpec.description` and `stepSpec.inputs`. Do not re-read `plan.json` — the orchestrator gave you everything you need.
+2. Use the tools listed in `stepSpec.toolsNeeded`. If a tool is unavailable, return immediately with an error explanation; do not improvise.
+3. Write the outputs listed in `stepSpec.expectedOutputs`. Each is a path under `workingDir/`.
+4. Check yourself against `stepSpec.successSignal`. Did your work satisfy it? If yes, return success; if no, return with a clear explanation of what's missing.
+
+## Return shape
+
+Return a structured summary to the orchestrator:
+
+```json
+{
+  "stepId": "<from stepSpec.id>",
+  "status": "success | partial | failed",
+  "outputsWritten": ["workingDir/<path>", "..."],
+  "summary": "string — one sentence",
+  "blockers": ["string — if status != success, what's missing"]
+}
+```
+
+## Boundaries
+
+- Do not modify `implStateDir`
+- Do not spawn further subagents
+- Do not do work outside `stepSpec` — if you think additional work is needed, return with a `partial` status and explain
+- Stay within your time budget; if you can't finish, return `partial` rather than blocking past the budget
+
+## Cross-reference
+
+Spec: §4.4.

package/dist/plugins/learner/skills/learn/strategist-prompt.md

@@ -0,0 +1,85 @@
+---
+description: Specialized fresh-context subagent for Strategize. Reads Orient findings, generates 2–4 candidate approaches, picks one with rationale, freezes success criteria + timing posture into a constitution record.
+tools: Bash, Read, Write
+---
+
+# Strategist (subagent role)
+
+You commit to one approach for this run. Your output is what Debrief later judges against — once you write success criteria, they are frozen.
+
+## Inputs (from your spawn prompt)
+
+- `goal`
+- `orientSummaryPath` — read this for context
+- `priorStrategiesPath` — read if non-null for prior promoted strategies for this kind
+- `workingDir`, `implStateDir` (read-only)
+- `outputDir` — write strategy.json + constitution.json here
+- `skillBundleCid`, `implStateDirShaAtStart` — for the constitution
+- `msUntilDeadline`
+
+## Diverge
+
+Generate 2–4 candidate approaches given the Orient findings. For each, name:
+
+- The angle (one sentence)
+- What success looks like
+- What could go wrong
+- The timing posture this approach implies
+
+## Converge
+
+Pick one. Articulate why it beats the alternatives — the rationale, not just the pick.
+
+## Freeze invariants
+
+Write `<outputDir>/strategy.json`:
+
+```json
+{
+  "approach": "string — chosen approach, descriptive",
+  "rationale": "string — why this beats alternatives",
+  "successCriteria": "string — concrete 'success if X' statement",
+  "timingPosture": "early-return | hold-and-revise | continuous-observation",
+  "constraints": ["string", "..."],
+  "rejectedAlternatives": [
+    { "approach": "string", "reason": "string" }
+  ]
+}
+```
+
+Compute the success-criteria CID:
+
+```bash
+SUCCESS_CID="sha256:$(printf '%s' '<successCriteria>' | sha256sum | cut -d' ' -f1)"
+```
+
+Write `<outputDir>/constitution.json`:
+
+```json
+{
+  "successCriteriaCid": "<SUCCESS_CID>",
+  "timingPosture": "<from strategy.json>",
+  "skillBundleCid": "<from input>",
+  "implStateDirSha": "<implStateDirShaAtStart from input>",
+  "editableScope": ["<implStateDir>/**", "<workingDir>/**"]
+}
+```
+
+Return to the dispatching section of `skills/learn/SKILL.md`: a one-paragraph summary of the chosen approach, success criteria, and timing posture.
+
+## Timing postures
+
+- `early-return` — finish work and exit before window end. Default for kinds where late information doesn't help.
+- `hold-and-revise` — work, wait until late, optionally revise based on world-state evolution, exit.
+- `continuous-observation` — submit early, monitor across window, occasionally adjust, exit at end.
+
+## Boundaries
+
+- Do not gather more info — Orient already did
+- Do not detail per-step actions — Plan does that
+- Do not modify `implStateDir`
+- Do not spawn further subagents
+
+## Cross-reference
+
+Spec: §4.2, §10.

package/dist/restart-daemon.d.ts

@@ -0,0 +1,90 @@
+/**
+ * In-process respawn helper for operator-triggered daemon restarts.
+ *
+ * Issue #289 added respawn-instead-of-exit so the operator panel survives a
+ * restart click. Issue #561 fixed the follow-on bug: the original respawn
+ * spawned the child *before* the parent had released its server sockets, so
+ * the child raced into `.listen(7332)` while the parent still held the port
+ * and died with EADDRINUSE / exitCode 11. The fix is `preSpawnCleanup` — an
+ * async hook the caller uses to close API + OTLP receivers before the child
+ * is spawned. With cleanup in place the port is free synchronously and the
+ * child binds on first try; without it (older callers, tests) the helper
+ * behaves as before.
+ *
+ * Every restart-required config change funnels through the same handler:
+ *
+ *   - POST /v1/setup/network              — RPC URL change
+ *   - POST /v1/setup/change-password      — keystore password rotation
+ *   - POST /v1/setup/solvernets/:name     — SolverNet enable/disable
+ *   - POST /v1/operator/join/:cid         — SolverNet join
+ *
+ * Headless gate: `JINN_NO_UI=1` (already the established headless flag in
+ * main.ts) skips the respawn — operators running `jinn run --no-ui` from a
+ * supervisor / systemd unit / docker entrypoint want the supervisor to
+ * decide whether to restart, not the daemon.
+ *
+ * The helper is split out from main.ts so it's unit-testable without
+ * touching the entry-point bootstrap path.
+ */
+import { spawn } from 'node:child_process';
+/**
+ * Options for `requestDaemonRestart`. All optional in production; the helper
+ * defaults to `process` / `node:child_process`. Tests inject doubles.
+ */
+export interface RequestDaemonRestartOptions {
+    /** Defaults to `process.env`. */
+    env?: NodeJS.ProcessEnv;
+    /** Defaults to `process.argv` (`[node, scriptPath, ...args]`). */
+    argv?: readonly string[];
+    /** Defaults to `process.execPath` (the node binary). */
+    execPath?: string;
+    /**
+     * Defaults to `node:child_process.spawn`. Injected for tests so we can
+     * assert what was spawned without actually forking node.
+     */
+    spawnFn?: typeof spawn;
+    /** Defaults to `(code) => process.exit(code)`. Injected for tests. */
+    exitFn?: (code: number) => void;
+    /** Defaults to `console.log`. Injected for tests to capture output. */
+    log?: (message: string) => void;
+    /**
+     * Delay (ms) between spawning the child and exiting the parent. Gives the
+     * child a moment to bind the API port before the parent vacates it.
+     * Defaults to 250ms per the issue body. Tests can pass 0 for synchrony.
+     */
+    exitDelayMs?: number;
+    /**
+     * Bypass the headless gate. The operator-dashboard Restart button passes
+     * this — when the operator clicks Restart, they explicitly want the
+     * daemon to come back, even under a supervisor. Supervisor-driven
+     * restart flows (MCP tools, signals) leave this `false` so the
+     * supervisor stays in charge.
+     */
+    forceRespawn?: boolean;
+    /**
+     * Optional async hook run *before* the replacement child is spawned. The
+     * caller uses this to close listening sockets the child will need to
+     * bind — API server (7332) and OTLP receiver (4317/4318) — so the child
+     * doesn't lose an EADDRINUSE race with the parent. Errors are caught and
+     * logged; the respawn still proceeds because leaving the operator
+     * stranded is worse than a noisy close. Skipped in headless mode.
+     */
+    preSpawnCleanup?: () => Promise<void>;
+}
+/**
+ * Pure predicate: true when the current env is headless and respawn should
+ * be skipped. Exposed so callers and tests can share the same check.
+ */
+export declare function isHeadless(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Handle an operator-triggered restart request.
+ *
+ * - In **interactive** mode (default), spawn a detached child that re-runs
+ *   the current node invocation, then exit after a short delay so the child
+ *   can bind the API port.
+ * - In **headless** mode (`JINN_NO_UI=1`), exit without respawning. The
+ *   supervisor is responsible for relaunching the daemon if it wants to.
+ *
+ * Returns the action taken (for tests). Production callers ignore the return.
+ */
+export declare function requestDaemonRestart(opts?: RequestDaemonRestartOptions): Promise<'respawned' | 'headless-exit'>;

package/dist/restart-daemon.js

@@ -0,0 +1,95 @@
+/**
+ * In-process respawn helper for operator-triggered daemon restarts.
+ *
+ * Issue #289 added respawn-instead-of-exit so the operator panel survives a
+ * restart click. Issue #561 fixed the follow-on bug: the original respawn
+ * spawned the child *before* the parent had released its server sockets, so
+ * the child raced into `.listen(7332)` while the parent still held the port
+ * and died with EADDRINUSE / exitCode 11. The fix is `preSpawnCleanup` — an
+ * async hook the caller uses to close API + OTLP receivers before the child
+ * is spawned. With cleanup in place the port is free synchronously and the
+ * child binds on first try; without it (older callers, tests) the helper
+ * behaves as before.
+ *
+ * Every restart-required config change funnels through the same handler:
+ *
+ *   - POST /v1/setup/network              — RPC URL change
+ *   - POST /v1/setup/change-password      — keystore password rotation
+ *   - POST /v1/setup/solvernets/:name     — SolverNet enable/disable
+ *   - POST /v1/operator/join/:cid         — SolverNet join
+ *
+ * Headless gate: `JINN_NO_UI=1` (already the established headless flag in
+ * main.ts) skips the respawn — operators running `jinn run --no-ui` from a
+ * supervisor / systemd unit / docker entrypoint want the supervisor to
+ * decide whether to restart, not the daemon.
+ *
+ * The helper is split out from main.ts so it's unit-testable without
+ * touching the entry-point bootstrap path.
+ */
+import { spawn } from 'node:child_process';
+/**
+ * Pure predicate: true when the current env is headless and respawn should
+ * be skipped. Exposed so callers and tests can share the same check.
+ */
+export function isHeadless(env = process.env) {
+    return env['JINN_NO_UI'] === '1';
+}
+/**
+ * Handle an operator-triggered restart request.
+ *
+ * - In **interactive** mode (default), spawn a detached child that re-runs
+ *   the current node invocation, then exit after a short delay so the child
+ *   can bind the API port.
+ * - In **headless** mode (`JINN_NO_UI=1`), exit without respawning. The
+ *   supervisor is responsible for relaunching the daemon if it wants to.
+ *
+ * Returns the action taken (for tests). Production callers ignore the return.
+ */
+export async function requestDaemonRestart(opts = {}) {
+    const env = opts.env ?? process.env;
+    const argv = opts.argv ?? process.argv;
+    const execPath = opts.execPath ?? process.execPath;
+    const spawnFn = opts.spawnFn ?? spawn;
+    const exitFn = opts.exitFn ?? ((code) => process.exit(code));
+    const log = opts.log ?? ((message) => console.log(message));
+    const exitDelayMs = opts.exitDelayMs ?? 250;
+    if (isHeadless(env) && !opts.forceRespawn) {
+        log('[main] Restart requested via operator MCP, but JINN_NO_UI=1 — exiting without respawn (let the supervisor decide).');
+        exitFn(0);
+        return 'headless-exit';
+    }
+    log('[main] Restart requested via operator MCP. Spawning replacement and exiting...');
+    // jinn-mono #561: release server sockets BEFORE the child spawns. Without
+    // this, the child loses an EADDRINUSE race on 7332 (and OTLP 4317/4318)
+    // and dies with exitCode 11 before it can take over.
+    if (opts.preSpawnCleanup) {
+        try {
+            await opts.preSpawnCleanup();
+        }
+        catch (err) {
+            log(`[main] preSpawnCleanup error (proceeding with respawn anyway): ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // argv[0] is the node binary; argv[1..] are the script + flags. The child
+    // re-runs the same script with the same flags, under the same node binary.
+    const childArgs = argv.slice(1);
+    const spawnOptions = {
+        detached: true,
+        stdio: 'inherit',
+        env,
+    };
+    const child = spawnFn(execPath, childArgs, spawnOptions);
+    // Detach so the parent can exit without taking the child with it.
+    child.unref();
+    // With preSpawnCleanup the port is already free; the small delay is kept
+    // as a paranoid belt-and-suspenders against any kernel-level lingering on
+    // SO_LINGER-disabled sockets. Tests pass 0.
+    if (exitDelayMs <= 0) {
+        exitFn(0);
+    }
+    else {
+        setTimeout(() => exitFn(0), exitDelayMs);
+    }
+    return 'respawned';
+}
+//# sourceMappingURL=restart-daemon.js.map

package/dist/restart-daemon.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"restart-daemon.js","sourceRoot":"","sources":["../src/restart-daemon.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,KAAK,EAAqB,MAAM,oBAAoB,CAAC;AA+C9D;;;GAGG;AACH,MAAM,UAAU,UAAU,CAAC,MAAyB,OAAO,CAAC,GAAG;IAC7D,OAAO,GAAG,CAAC,YAAY,CAAC,KAAK,GAAG,CAAC;AACnC,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,OAAoC,EAAE;IAEtC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC;IACpC,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IACvC,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ,CAAC;IACnD,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,IAAI,KAAK,CAAC;IACtC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC,IAAY,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IACrE,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,OAAe,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;IACpE,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,IAAI,GAAG,CAAC;IAE5C,IAAI,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;QAC1C,GAAG,CACD,oHAAoH,CACrH,CAAC;QACF,MAAM,CAAC,CAAC,CAAC,CAAC;QACV,OAAO,eAAe,CAAC;IACzB,CAAC;IAED,GAAG,CAAC,gFAAgF,CAAC,CAAC;IAEtF,0EAA0E;IAC1E,wEAAwE;IACxE,qDAAqD;IACrD,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;QACzB,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QAC/B,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,GAAG,CACD,kEACE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CACjD,EAAE,CACH,CAAC;QACJ,CAAC;IACH,CAAC;IAED,0EAA0E;IAC1E,2EAA2E;IAC3E,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAChC,MAAM,YAAY,GAAiB;QACjC,QAAQ,EAAE,IAAI;QACd,KAAK,EAAE,SAAS;QAChB,GAAG;KACJ,CAAC;IACF,MAAM,KAAK,GAAG,OAAO,CAAC,QAAQ,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;IACzD,kEAAkE;IAClE,KAAK,CAAC,KAAK,EAAE,CAAC;IAEd,yEAAyE;IACzE,0EAA0E;IAC1E,4CAA4C;IAC5C,IAAI,WAAW,IAAI,CAAC,EAAE,CAAC;QACrB,MAAM,CAAC,CAAC,CAAC,CAAC;IACZ,CAAC;SAAM,CAAC;QACN,UAAU,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC;IAC3C,CAAC;IAED,OAAO,WAAW,CAAC;AACrB,CAAC"}

package/dist/setup/halt-mode.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Halt-and-resume gate (jinn-mono-hjex.6).
+ *
+ * When bootstrap fails after the setup API has come up, we want the dashboard
+ * to stay alive so the operator can click Retry from `BootstrapErrorCard`
+ * (see `main.ts` halt-and-resume loop). That mode is only safe when there is
+ * actually a human (or watcher) on the other side; in CI / agent-driven flows
+ * driven with `JINN_NO_UI=1` or `JINN_NO_DAEMON=1` no Retry click is coming,
+ * so a halt must surface as a fatal exit immediately rather than suspending
+ * in the retry loop forever.
+ *
+ * This predicate is the single source of truth for that gate.
+ */
+export declare function keepSetupUiOnBootstrapError(env?: NodeJS.ProcessEnv): boolean;

package/dist/setup/halt-mode.js

@@ -0,0 +1,17 @@
+/**
+ * Halt-and-resume gate (jinn-mono-hjex.6).
+ *
+ * When bootstrap fails after the setup API has come up, we want the dashboard
+ * to stay alive so the operator can click Retry from `BootstrapErrorCard`
+ * (see `main.ts` halt-and-resume loop). That mode is only safe when there is
+ * actually a human (or watcher) on the other side; in CI / agent-driven flows
+ * driven with `JINN_NO_UI=1` or `JINN_NO_DAEMON=1` no Retry click is coming,
+ * so a halt must surface as a fatal exit immediately rather than suspending
+ * in the retry loop forever.
+ *
+ * This predicate is the single source of truth for that gate.
+ */
+export function keepSetupUiOnBootstrapError(env = process.env) {
+    return env['JINN_NO_UI'] !== '1' && env['JINN_NO_DAEMON'] !== '1';
+}
+//# sourceMappingURL=halt-mode.js.map

package/dist/setup/halt-mode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"halt-mode.js","sourceRoot":"","sources":["../../src/setup/halt-mode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,2BAA2B,CAAC,MAAyB,OAAO,CAAC,GAAG;IAC9E,OAAO,GAAG,CAAC,YAAY,CAAC,KAAK,GAAG,IAAI,GAAG,CAAC,gBAAgB,CAAC,KAAK,GAAG,CAAC;AACpE,CAAC"}