@jinn-network/client 0.1.2 → 0.1.3-canary.2d6b2676

package/plugins/claude-code-learner/skills/debrief/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: debrief
+description: Use when the coordinator reaches the Debrief phase. Optionally launch explorer subagents for cross-operator / outcome reads, then launch one analyst subagent with all evidence to produce the analysis Improve consumes.
+allowed-tools: Bash, Read, Write, Agent
+---
+
+# Debrief skill
+
+Mirrors Orient — gather + sense-make in hindsight. You may launch explorers (for cross-operator reads or fresh world-state probes) and always launch the analyst.
+
+## Inputs
+
+- All `workingDir/.<prior-phase>/` outputs through Execute
+- Strategy + constitution from `workingDir/.strategize/`
+- Plan from `workingDir/.plan/`
+- `implStateDir/runs/` for own history
+- The intent
+
+## Optional: launch explorers
+
+If the operator's policy enables cross-operator reads or fresh-world-state probes, spawn `explorer` subagents in parallel for each post-execution topic:
+
+- `outcome-probe` — re-pull venue / market / on-chain state to see post-execution outcome
+- `cross-operator-comparison` — knowledge-tree query for similar runs by other operators (only if policy allows)
+
+Same Agent-tool spawn pattern as Orient. Outputs land under `workingDir/.debrief/<topic>.json`.
+
+## Launch the analyst
+
+```
+Use the Agent tool to spawn a fresh-context subagent with role `analyst`.
+Pass it inputs:
+  intent             = <copy of intent>
+  strategyPath       = workingDir/.strategize/strategy.json
+  constitutionPath   = workingDir/.strategize/constitution.json
+  planPath           = workingDir/.plan/plan.json
+  executeSummaryPath = workingDir/.execute/summary.json
+  executeLogPath     = workingDir/.execute/log.jsonl
+  orientSummaryPath  = workingDir/.orient/summary.json
+  debriefExplorerPaths = [workingDir/.debrief/<topic>.json, ...]
+  ownHistoryPath     = implStateDir/runs/index.json (or null)
+  workingDir         = <path>
+  implStateDir       = <path, read-only>
+  outputPath         = workingDir/.debrief/analysis.json
+  msUntilEndTs       = <current value>
+The subagent loads its `analyst` role and writes analysis.json. Return its summary.
+```
+
+## After it returns
+
+Verify `workingDir/.debrief/analysis.json` exists. If not, write `workingDir/.errors/debrief.json` and abort.
+
+Return to the coordinator: a one-paragraph plain-English summary plus the path to `analysis.json`.
+
+## Boundaries
+
+- Do not change success criteria — frozen in Strategize
+- Do not modify `implStateDir` — Improve does that
+- Do not invent recommendations — every recommendation must be grounded in the evidence
+
+## Cross-reference
+
+Spec: §4.5.

package/plugins/claude-code-learner/skills/execute/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: execute
+description: Use when the coordinator reaches the Execute phase. Walk the plan, launch one step-worker subagent per work step, honor wait steps, decide at runtime when stuck.
+allowed-tools: Bash, Read, Write, Edit, Glob, Grep, Agent, Skill
+---
+
+# Execute skill
+
+Walk the plan and drive it. Workers are spawned by you (the coordinator session via this skill); they do not nest further.
+
+## Inputs
+
+- `workingDir/.plan/plan.json` — the steps
+- `workingDir/.strategize/strategy.json` — success criteria + timing posture
+- `workingDir/.orient/summary.json` — grounding
+- The intent + window + remaining time budget
+
+## Walk the plan
+
+For each step in order, respecting `concurrency` markings:
+
+### Work steps
+
+Spawn a `step-worker` subagent via the Agent tool:
+
+```
+Use the Agent tool to spawn a fresh-context subagent with role `step-worker`.
+Pass it inputs:
+  stepSpec     = <the entire step object from plan.json>
+  intent       = <copy of intent>
+  workingDir   = <path>
+  implStateDir = <path, read-only>
+  msUntilEndTs = <current value>
+```
+
+For parallel-batch steps (steps sharing a `concurrency: parallel-batch-X` label), spawn the whole batch concurrently if your harness supports it; wait for all to return before advancing.
+
+After a worker returns:
+- The worker's self-reported `status` and `blockers` are evidence; the authoritative verdict is your re-check of the step's `successSignal` against actual outputs on disk.
+- Check `successSignal` — did the step succeed?
+- If yes: append to `workingDir/.execute/log.jsonl` (carrying the worker's `status` and `blockers` into the log entry) and advance.
+- If no: see "When stuck."
+
+### Wait steps
+
+Use the harness's wait primitive (per spec §8 harness-adapter contract). Plan-emitted wait steps may include any combination of `durationMs`, `untilTs`, and `condition`; treat absent and explicit `null` identically as "not set." When multiple wakers are set, wake on the first to fire (per spec §5: `wait` wakes when any of duration / deadline / condition fires). The abort signal from the daemon (`window.endTs`) always overrides any wait.
+
+### When stuck
+
+When a step fails its success signal or a worker returns without expected outputs, judge:
+
+- **Continue** — accept partial; advance.
+- **Retry-step** — spawn a fresh worker for the same step. Cap at 2 retries unless step `abortCondition` says otherwise.
+- **Replan** — archive the current plan and re-invoke the plan skill, then continue Execute on the new plan. Concretely: rename `workingDir/.plan/plan.json` to `workingDir/.plan/plan-v<N>.json` where N is the next unused integer (start at 1), then load `Skill claude-code-learner:plan` again. The plan skill writes a fresh `plan.json` based on what's now in `workingDir/` (including the archived prior plans, the execute log up to the failure, and a new `workingDir/.plan/replan-context.json` you write with `{ failedStepId, blockers, partialOutputs[] }`). Continue Execute on the new `plan.json`.
+- **Abort** — write `workingDir/.errors/execute.json` with failure context; exit Execute. Coordinator continues to Debrief / Improve / Memory consolidation so partial work is harvested.
+
+Explain your judgment in `workingDir/.execute/log.jsonl`.
+
+## Outputs
+
+Throughout the phase:
+- `workingDir/.execute/log.jsonl` — one entry per step boundary: `{ ts, stepId, decision, summary, retryCount, workerStatus, workerBlockers }`. `workerStatus` and `workerBlockers` come directly from the step-worker's return shape so Debrief sees both the worker's self-assessment and Execute's verdict.
+- Per-step outputs as the plan declared
+
+At end:
+- `workingDir/.execute/summary.json`:
+  ```json
+  {
+    "stepsCompleted": ["step-1", "step-2"],
+    "stepsFailed": [],
+    "decisions": ["continue", "retry-step", "continue"],
+    "elapsedMs": 0,
+    "returnReason": "all-steps-completed | early-return | hold-and-revise-window-end | continuous-observation-window-end | abort"
+  }
+  ```
+
+## Boundaries
+
+- Do not invoke Strategize — strategy is frozen
+- Do not write to `implStateDir` — Improve does that
+- Do not run Debrief / Improve / Memory consolidation — coordinator does that next
+- Do not call wait for arbitrarily long with no plan justification
+- Do not spawn agents that themselves spawn agents (your workers are one level deep)
+
+## Cross-reference
+
+Spec: §4.4, §5.

package/plugins/claude-code-learner/skills/improve/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: improve
+description: Use when the coordinator reaches the Improve phase. Launch one promoter subagent with the analysis; commit each accepted mutation to implStateDir as a separate git commit; emit promotion records.
+allowed-tools: Bash, Read, Write, Edit, Agent
+---
+
+# Improve skill
+
+Launch the promoter; commit its mutations. Changes take effect NEXT run.
+
+## Inputs
+
+- `workingDir/.debrief/analysis.json`
+- `implStateDir/policy.json` if present (operator policy on what Improve may touch)
+- `implStateDir/` (current durable self)
+
+## Launch the promoter
+
+```
+Use the Agent tool to spawn a fresh-context subagent with role `promoter`.
+Pass it inputs:
+  analysisPath       = workingDir/.debrief/analysis.json
+  policyPath         = implStateDir/policy.json (or null)
+  implStateDir       = <path, read-write for the promoter>
+  workingDir         = <path>
+  outputDir          = workingDir/.improve/
+  msUntilEndTs       = <current value>
+The promoter writes mutations directly into implStateDir, commits each as
+a separate git commit (the session-start hook configured the author
+identity already), and writes one promotion_record per mutation under
+workingDir/.improve/promotions/.
+```
+
+## After it returns
+
+Read `workingDir/.improve/summary.json`. Verify:
+- `implStateDirShaAfter` matches `git -C <implStateDir> rev-parse HEAD`
+- One `promotion_record` per accepted change
+- Operator-access requests under `workingDir/.operator-requests/` if any
+
+If anything is inconsistent, write `workingDir/.errors/improve.json` and abort.
+
+Return to the coordinator: a one-paragraph summary of what changed (or didn't) and why.
+
+## Boundaries
+
+- Do not pre-judge what to mutate — that's the promoter's reasoning
+- Do not commit yourself — the promoter commits as it goes
+- Do not modify anything outside `workingDir/.improve/` from this skill
+
+## Cross-reference
+
+Spec: §4.6, §6.2, §6.4, §7.

package/plugins/claude-code-learner/skills/memory-consolidation/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: memory-consolidation
+description: Use when the coordinator reaches the Memory consolidation phase. Launch one consolidator subagent that curates implStateDir (prune unused, revert regressions) and workingDir (set public/private boundary); commits durable curation as one separate commit.
+allowed-tools: Bash, Read, Write, Edit, Agent
+---
+
+# Memory consolidation skill
+
+Launch the consolidator; verify outputs.
+
+## Inputs
+
+- `workingDir/.debrief/analysis.json` (trend signals, regression flags)
+- `workingDir/.improve/summary.json` + `promotions/` (Improve's mutations)
+- `implStateDir/` and `workingDir/` (full)
+- `implStateDir/policy.json` (retention rules, size caps)
+
+## Launch the consolidator
+
+```
+Use the Agent tool to spawn a fresh-context subagent with role `consolidator`.
+Pass it inputs:
+  analysisPath        = workingDir/.debrief/analysis.json
+  improveSummaryPath  = workingDir/.improve/summary.json
+  improvePromotionsDir = workingDir/.improve/promotions/
+  policyPath          = implStateDir/policy.json (or null)
+  implStateDir        = <path, read-write>
+  workingDir          = <path, read-write>
+  outputPath          = workingDir/.memory-consolidation/consolidation_record.json
+  msUntilEndTs        = <current value>
+The consolidator does both workstreams (durable + ephemeral), writes a
+single git commit on implStateDir for the durable curation, and produces
+the consolidation_record.
+```
+
+## After it returns
+
+Verify the consolidation_record exists. If the consolidator made a commit, `implStateDirShaAfter` must match `git -C <implStateDir> rev-parse HEAD`. If no commit was made (empty curation set), `implStateDirShaAfter` must equal `implStateDirShaBefore` and HEAD remains at that sha.
+
+Return to the coordinator: a one-paragraph summary.
+
+## Boundaries
+
+- Do not promote new content — Improve already did
+- Do not modify success criteria, plan, or analysis
+
+## Cross-reference
+
+Spec: §4.7, §6.1.

package/plugins/claude-code-learner/skills/orient/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: orient
+description: Use when the coordinator reaches the Orient phase. Decide what topics to gather; launch one explorer subagent per topic; collate findings into a summary Strategize will consume.
+allowed-tools: Bash, Read, Write, Agent
+---
+
+# Orient skill
+
+You are coordinating the Orient phase. Your only jobs are: decide what topics need gathering for this intent, launch an `explorer` subagent for each topic, and collate their results.
+
+## Inputs
+
+- The intent and paths from the coordinator session
+- `workingDir` — write findings here
+- `implStateDir` — read-only in this phase
+
+## Decide what topics to gather
+
+Choose from these typical categories; add or omit based on the intent:
+
+1. **intent-parse** — what's the goal, solverType, window, spec, eligibility? Always include.
+2. **world-state** — for solverTypes with a venue (portfolio.v0, prediction.v0, etc.), pull current relevant state. Include if the solverType has a venue.
+3. **own-history** — list prior runs of this solverType by this operator. Include if `implStateDir/runs/index.json` exists or the harness exposes a knowledge-tree query.
+4. **others-history** — recent runs of this solverType by other operators. Include only if `implStateDir/policy.json` sets `allowCrossOperatorReads: true` AND the harness exposes the query tool.
+
+## Launch explorers
+
+For each topic chosen, spawn an `explorer` subagent via the Agent tool:
+
+```
+Use the Agent tool to spawn a fresh-context subagent with role `explorer`.
+Pass it inputs:
+  topic        = <topic name, e.g. "world-state">
+  intent       = <copy of intent>
+  scope        = <topic-specific scope; explorer's role definition explains what it expects>
+  workingDir   = <path>
+  implStateDir = <path, read-only>
+  outputPath   = workingDir/.orient/<topic>.json
+  msUntilEndTs = <current value>
+The subagent will load its `explorer` role definition, gather, write findings, return a summary.
+```
+
+Spawn explorers in parallel if your harness supports it; otherwise spawn sequentially. The explorers themselves do not spawn further agents (no nesting).
+
+## Collate
+
+After all explorers return, read each `workingDir/.orient/<topic>.json` and write `workingDir/.orient/summary.json`:
+
+```json
+{
+  "intent": { "id": "...", "solverType": "...", "window": { "startTs": 0, "endTs": 0 } },
+  "topics": [
+    { "topic": "intent-parse", "artifact": "workingDir/.orient/intent-parse.json", "summary": "...", "flags": [] },
+    { "topic": "world-state", "artifact": "workingDir/.orient/world-state.json", "summary": "...", "flags": ["stale"] }
+  ],
+  "openQuestions": ["string — anything Strategize needs to know was uncertain or unavailable"]
+}
+```
+
+Return to the coordinator: a one-paragraph summary and the path to `summary.json`.
+
+## Boundaries
+
+- Do not pick an approach — Strategize's job
+- Do not write a plan — Plan's job
+- Do not execute work — Execute's job
+- Do not modify `implStateDir`
+
+## Cross-reference
+
+Spec: §4.1.

package/plugins/claude-code-learner/skills/plan/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: plan
+description: Use when the coordinator reaches the Plan phase. Launch one planner subagent with the strategy; receive the plan; persist it under workingDir/.plan/.
+allowed-tools: Bash, Read, Write, Agent
+---
+
+# Plan skill
+
+Launch the planner; persist its output.
+
+## Inputs
+
+- `workingDir/.strategize/strategy.json`
+- `workingDir/.orient/summary.json` for grounding
+- `implStateDir/plans/<solverType>/` if any prior promoted plan templates
+- The intent
+- On replan: `workingDir/.plan/replan-context.json` (failure context written by Execute) and any prior `workingDir/.plan/plan-v<N>.json` archives. Read these to ground the new plan in what just failed.
+
+## Launch the planner
+
+```
+Use the Agent tool to spawn a fresh-context subagent with role `planner`.
+Pass it inputs:
+  intent              = <copy of intent>
+  strategyPath        = workingDir/.strategize/strategy.json
+  orientSummaryPath   = workingDir/.orient/summary.json
+  priorPlanTemplatesPath = implStateDir/plans/<solverType>/ (or null)
+  replanContextPath   = workingDir/.plan/replan-context.json (or null on first plan)
+  priorPlanArchives   = [workingDir/.plan/plan-v1.json, ...] (or empty on first plan)
+  workingDir          = <path>
+  implStateDir        = <path, read-only>
+  outputPath          = workingDir/.plan/plan.json
+  msUntilEndTs        = <current value>
+```
+
+## After it returns
+
+Verify `workingDir/.plan/plan.json` exists. If not, write `workingDir/.errors/plan.json` and abort.
+
+Return to the coordinator: a one-line summary ("plan with N steps, M parallel batches, K wait checkpoints") and the path to `plan.json`.
+
+## Boundaries
+
+- Do not change success criteria or timing posture — frozen in Strategize
+- Do not execute — Execute does that
+- Do not modify `implStateDir`
+
+## Cross-reference
+
+Spec: §4.3, §5.

package/plugins/claude-code-learner/skills/strategize/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: strategize
+description: Use when the coordinator reaches the Strategize phase. Launch one strategist subagent with the Orient summary; receive a strategy + constitution; persist them under workingDir/.strategize/.
+allowed-tools: Bash, Read, Write, Agent
+---
+
+# Strategize skill
+
+Launch the strategist; persist its outputs.
+
+## Inputs
+
+- `workingDir/.orient/summary.json` (and per-topic files for context)
+- `implStateDir/strategies/<solverType>/` if any prior promoted strategies exist
+- The intent
+
+## Launch the strategist
+
+```
+Use the Agent tool to spawn a fresh-context subagent with role `strategist`.
+Pass it inputs:
+  intent                 = <copy of intent>
+  orientSummaryPath      = workingDir/.orient/summary.json
+  priorStrategiesPath    = implStateDir/strategies/<solverType>/   (or null if absent)
+  workingDir             = <path>
+  implStateDir           = <path, read-only>
+  outputDir              = workingDir/.strategize/
+  skillBundleCid         = <from coordinator boot>
+  implStateDirShaAtStart = <from coordinator boot>
+  msUntilEndTs           = <current value>
+The subagent loads its `strategist` role, does the divergent/convergent
+selection, and writes strategy.json + constitution.json. Return its summary.
+```
+
+## After it returns
+
+Verify both files exist:
+- `workingDir/.strategize/strategy.json`
+- `workingDir/.strategize/constitution.json`
+
+If either is missing, write `workingDir/.errors/strategize.json` with the failure context and abort.
+
+Return to the coordinator: a one-paragraph summary of the chosen approach + success criteria + timing posture, plus paths to both files.
+
+## Boundaries
+
+- Do not generate the strategy yourself — that's the strategist agent's job in fresh context
+- Do not modify `implStateDir`
+- Never run a second strategist after the first has committed (no re-strategizing mid-run)
+
+## Cross-reference
+
+Spec: §4.2, §10.

package/plugins/jinn-prediction-plugin/.claude-plugin/plugin.json

@@ -0,0 +1,89 @@
+{
+  "name": "jinn-prediction-plugin",
+  "version": "0.1.0",
+  "description": "Prediction SolverPlugin for prediction.v0 tasks.",
+  "jinn": {
+    "solverType": "prediction.v0",
+    "schemas": {
+      "task": {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "type": "object",
+        "required": ["id", "description", "solverType", "role", "spec", "window"],
+        "properties": {
+          "id": { "type": "string" },
+          "description": { "type": "string" },
+          "solverType": { "const": "prediction.v0" },
+          "role": { "enum": ["restoration", "evaluation"] },
+          "spec": {
+            "type": "object",
+            "required": ["question", "oracle"],
+            "properties": {
+              "question": {
+                "type": "object",
+                "required": ["kind", "text"],
+                "properties": {
+                  "kind": { "enum": ["threshold", "range"] },
+                  "text": { "type": "string" }
+                },
+                "additionalProperties": true
+              },
+              "oracle": {
+                "type": "object",
+                "required": ["venue"],
+                "properties": {
+                  "venue": { "type": "string" }
+                },
+                "additionalProperties": true
+              }
+            },
+            "additionalProperties": true
+          },
+          "window": {
+            "type": "object",
+            "required": ["startTs", "endTs"],
+            "properties": {
+              "startTs": { "type": "number" },
+              "endTs": { "type": "number" }
+            },
+            "additionalProperties": false
+          },
+          "eligibility": { "type": "object" }
+        },
+        "additionalProperties": true
+      },
+      "solution": {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "type": "object",
+        "required": ["prediction", "confidence"],
+        "properties": {
+          "prediction": { "type": "number" },
+          "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+          "rationale": { "type": "string" },
+          "sources": { "type": "array", "items": { "type": "string" } }
+        },
+        "additionalProperties": true
+      },
+      "verdict": {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "type": "object",
+        "required": ["verdict", "score"],
+        "properties": {
+          "verdict": { "enum": ["PASS", "FAIL", "REJECTED", "INDETERMINATE"] },
+          "score": { "type": "number", "minimum": 0, "maximum": 1 },
+          "scoreBasis": { "type": "string" }
+        },
+        "additionalProperties": true
+      }
+    },
+    "mcpServers": {
+      "polymarket": {
+        "command": "node",
+        "args": ["mcp/polymarket-server.mjs"]
+      }
+    },
+    "skills": [
+      "skills/base-rate-forecasting/SKILL.md",
+      "skills/calibration/SKILL.md"
+    ]
+  }
+}

package/plugins/jinn-prediction-plugin/mcp/polymarket-server.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+process.stdin.resume();

package/plugins/jinn-prediction-plugin/schemas/prediction-v0-solution.schema.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "required": ["prediction", "confidence"],
+  "properties": {
+    "prediction": { "type": "number" },
+    "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+    "rationale": { "type": "string" },
+    "sources": { "type": "array", "items": { "type": "string" } }
+  },
+  "additionalProperties": true
+}

package/plugins/jinn-prediction-plugin/schemas/prediction-v0-task.schema.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "required": ["question", "oracle"],
+  "properties": {
+    "question": {
+      "type": "object",
+      "required": ["kind", "text"],
+      "properties": {
+        "kind": { "enum": ["threshold", "range"] },
+        "text": { "type": "string" }
+      },
+      "additionalProperties": true
+    },
+    "oracle": {
+      "type": "object",
+      "required": ["venue"],
+      "properties": {
+        "venue": { "type": "string" }
+      },
+      "additionalProperties": true
+    }
+  },
+  "additionalProperties": true
+}

package/plugins/jinn-prediction-plugin/schemas/prediction-v0-verdict.schema.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "required": ["verdict", "score"],
+  "properties": {
+    "verdict": { "enum": ["PASS", "FAIL", "REJECTED", "INDETERMINATE"] },
+    "score": { "type": "number", "minimum": 0, "maximum": 1 },
+    "scoreBasis": { "type": "string" }
+  },
+  "additionalProperties": true
+}

package/plugins/jinn-prediction-plugin/skills/base-rate-forecasting/SKILL.md

@@ -0,0 +1,3 @@
+# Base-Rate Forecasting
+
+Use reference classes before inside-view adjustments. State the base rate, the adjustment, and the final probability.

package/plugins/jinn-prediction-plugin/skills/calibration/SKILL.md

@@ -0,0 +1,3 @@
+# Calibration
+
+Express uncertainty numerically. Prefer calibrated probability ranges and identify the evidence that would move the forecast.