@jentrix/cli 0.5.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jentrix
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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 THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,54 @@
+# @jentrix/cli
+
+`jentrix` is a command-line client for the [Jentrix](https://tm.jentrix.ai) MCP
+surface. It turns every MCP tool into a shell command —
+`jentrix task list --board <id> --json | jq …` — so agents and humans can drive
+boards from bash with no bespoke API.
+
+It is a **thin client over the same MCP endpoint** the agent platform uses, so
+it inherits scopes, workspace pinning, rate limits, idempotency,
+`expectedUpdatedAt` freshness, and agent attribution by construction.
+
+## Install
+
+```bash
+npm install -g @jentrix/cli
+# or: brew install jentrix-au/tap/jentrix
+jentrix --version
+```
+
+Requires Node ≥ 20. You can also run it without installing:
+`npx @jentrix/cli --help` (`pnpm dlx @jentrix/cli --help`).
+
+Install the bundled connected-session plugin with `jentrix plugin install`
+(Claude Code default) or `jentrix plugin install codex`; both require the
+matching `@jentrix/runner`, which the installer adds when missing.
+
+For a local self-hosted workflow runner, install the matching
+`@jentrix/runner` version, sign in to Claude Code and/or Codex yourself,
+then run `jentrix runner doctor`,
+`jentrix runner setup --runtime claude|codex|all`, and `jentrix runner up`.
+Setup is preview-first; pass `--yes` only after reviewing the plan. Full details
+and blocker recovery are in the [runner guide](https://tm.jentrix.ai/docs/cli#local-workflow-runner).
+
+## Quickstart
+
+```bash
+export STACKS_TOKEN=tm_your_token                     # mint at /account/tokens
+export STACKS_MCP_URL=https://tm.jentrix.ai/api/mcp   # default; override for dev
+jentrix whoami
+jentrix task list --board <id> --json | jq .
+```
+
+`STACKS_TOKEN` / `STACKS_MCP_URL` are the same env vars the reference agents
+use, so one `.env` serves both. Humans can also `jentrix login` (OAuth in the
+browser); agents should prefer a scoped `STACKS_TOKEN`.
+
+## Documentation
+
+Full command reference, auth precedence, exit codes, and idempotency/conflict
+recipes: **https://tm.jentrix.ai/docs/cli**
+
+## License
+
+MIT © Jentrix

package/claude-plugin/.claude-plugin/marketplace.json

@@ -0,0 +1,16 @@
+{
+  "name": "jentrix",
+  "description": "Jentrix connected-session plugin for Claude Code.",
+  "owner": {
+    "name": "Jentrix"
+  },
+  "plugins": [
+    {
+      "name": "jentrix",
+      "source": "./",
+      "description": "Bind a Claude Code session to a Jentrix project: /jentrix-connect, /jentrix-align, /jentrix-status, /jentrix-end over the Jentrix CLI, with trusted lifecycle hooks supplying the session id.",
+      "category": "productivity",
+      "keywords": ["jentrix", "sessions", "mcp", "agents", "jentrix"]
+    }
+  ]
+}

package/claude-plugin/.claude-plugin/plugin.json

@@ -0,0 +1,5 @@
+{
+  "name": "jentrix",
+  "description": "Connect this Claude Code session to a Jentrix project: /jentrix-connect binds the current session (trusted lifecycle hooks supply the session id), /jentrix-align runs the MVP alignment wizard, /jentrix-status and /jentrix-end wrap the same session operations. Business logic lives in the Jentrix CLI — removing this plugin leaves `jentrix session attach` as the universal fallback.",
+  "version": "0.4.0"
+}

package/claude-plugin/commands/jentrix-align.md

@@ -0,0 +1,113 @@
+---
+description: Align this session to a Jentrix work layer (workspace → project → task → owner) with a server-confirmed alignment snapshot
+allowed-tools: Bash(jentrix align:*), Bash(jentrix session:*)
+---
+
+Run the Jentrix MVP alignment wizard for THIS session. The question set is
+fixed — workspace, project, project name, work item, task title, owner,
+confirmation — and every answer is a choice selection except `project_name`
+and `task_title`, which are `kind: "freetext"`: the operator types them. You
+present the questions; the operator decides. Do NOT invent extra questions,
+and do NOT answer any question yourself.
+
+1. Run `jentrix align --questions --json` with the Bash tool. It prints the
+   detection summary (repo, branch, provider), `currentAlignment` (when the
+   session is already aligned), `preconditions` (the doctor's checks, run up
+   front), and the fixed `questions` array.
+2. If any precondition has status `"fail"` or `"warn"`, relay its `detail`
+   (and `fix`) to the operator BEFORE asking questions — a failure caught
+   here saves answering everything and then failing at submit.
+3. If `currentAlignment` is non-null: show it to the operator and ask —
+   using the native choice UI (AskUserQuestion) — whether to keep it or
+   re-align. Keep → relay the current snapshot and stop.
+4. For each question whose `status` is `"ask"`, present its `choices`
+   verbatim through the native choice UI (AskUserQuestion), preserving the
+   labels. If the question carries a `notice`, relay it to the operator
+   verbatim BEFORE the choices — it discloses a degraded list (e.g. repo
+   discovery unavailable, so the list is the whole workspace). The "Other…"
+   choice is the explicit free-text escape: when picked, let the operator
+   type the id/slug. A question whose `status` is `"skipped"` was resolved
+   by detection — tell the operator what was resolved (e.g. the workspace),
+   don't re-ask it.
+5. After the project answer, re-run
+   `jentrix align --questions --json --project <chosen>` to load the
+   work-item and owner choices, then continue asking. If the operator picked
+   "Create a new project from this repo", the NEXT question is
+   `project_name` (already in the payload, `kind: "freetext"`): relay its
+   `prompt` verbatim and collect the name as free text FROM THE OPERATOR —
+   never propose name options, never fill it in yourself. Then re-run
+   `jentrix align --questions --json --new-project "<name>"` — the work-item
+   and owner questions do not depend on an existing project.
+6. If the operator picked "New task", the NEXT question is `task_title`
+   (already in the payload, `kind: "freetext"`). Relay its `prompt` verbatim
+   and collect the title as free text FROM THE OPERATOR — never propose
+   title options, never fill it in yourself: it becomes the board-permanent
+   task title. Pass it as `--new-task "<title>"` on the next `--questions`
+   run and the final submit.
+7. The confirmation question's `prompt` embeds `disclosures` — every side
+   effect submitting will perform (project/board/task creation, repo link,
+   session host, capture mode) plus any notices. Present that prompt
+   VERBATIM and IN FULL through the choice UI; never summarize, trim, or
+   reorder the disclosure lines. Confirm means the operator approved
+   exactly that list.
+8. On Confirm, submit exactly once:
+   `jentrix align --json --yes (--project <id> | --new-project "<name>") (--task <taskId> | --new-task "<title>" | --session-level) [--owner <userId>]`
+9. Echo the returned `alignment` snapshot VERBATIM to the operator — it is
+   the server-confirmed "we agree" record. Then continue the session's work.
+10. Move the aligned task to the board's working column when you start work
+    on it. Read the real columns with `jentrix column list --board <boardId>`
+    and move with
+    `jentrix task move --task <taskId> --to-column-id <columnId>`. Use only
+    the columns the board actually has — never invent a status. `/jentrix-end`
+    moves it to a terminal column when the work is genuinely finished. A
+    board that never moves is a board that lies about what is in flight.
+11. If align wrote `./.mcp.json`, relay that line too: MCP servers load at
+    session start, so the tools in THIS session still point wherever they
+    pointed before. Tell the operator to reconnect the MCP server (or start a
+    new session) before relying on `list_workspaces` / `create_task` / any
+    other Jentrix MCP tool — otherwise those calls land in a different
+    deployment, silently.
+
+    The written server carries **no credential and no `Authorization`
+    header**: it authenticates with the deployment over OAuth. So the next
+    session needs the operator to approve the consent screen once — in Claude
+    Code, `/mcp` → `jentrix` → Authenticate — and nothing needs exporting. Say
+    that plainly; a session that has not authorized simply has no
+    `mcp__jentrix__*` tools, which looks identical to the endpoint being
+    wrong. If align reports removing an existing `Authorization` header, relay
+    that too: it is the repair (a header switches OAuth discovery off), and
+    `jentrix align --pat` puts it back for a headless checkout.
+
+Notes for you (the assistant):
+
+- Do NOT invent a `--provider-session` value. The CLI reads the current
+  session id from the TRUSTED lifecycle-hook context this plugin records, and
+  a model-authored id is never acceptable.
+  There is now ONE defined repair path, and only one. The `--questions`
+  payload carries a `session` precondition and the confirmation card names
+  the provider session id and the transcript the host will watch. When that
+  precondition is `warn` — typically "a NEWER live Claude session <id> was
+  recorded in <dir>" — **surface it to the operator before asking anything
+  else**, together with the `fix` string the precondition carries. If the
+  operator confirms the named session is the one you are running in, re-run
+  with the id **exactly as the precondition printed it** (it came from the
+  trusted hook file, not from you) plus `--transcript-path` if the payload
+  names one. Never proceed silently past that warning: on 2026-08-11 an
+  alignment bound a 35-hour-dead session this way and lost the entire run's
+  token telemetry at exit 0.
+- The confirmation card now names the binding (`bind provider session …`,
+  `the session host will watch …`) and any `./.mcp.json` write. Those are
+  side effects like any other — present them verbatim with the rest.
+- TRACE capture stays OFF for aligned sessions by default (typed artifacts
+  only). Only pass `--capture` when the operator explicitly asks for full
+  transcript capture — and the confirmation disclosures will then say
+  capture is ON; make sure the operator saw that before confirming.
+- When talking to the operator, use the choice LABELS, never internal ids
+  like `__create__` or `__new__` — those are flag values, not words a human
+  should be asked to type.
+- Re-aligning to the SAME project converges on the existing session (safe to
+  repeat). Aligning this provider session to a DIFFERENT project requires
+  ending the current session first (`jentrix session end`) — a `preconditions`
+  entry warns about this up front, and the refusal names the same fix.
+- If a command fails, show its error verbatim — it names the blocker and the
+  fallback. Do not improvise a workaround.

package/claude-plugin/commands/jentrix-checkpoint.md

@@ -0,0 +1,56 @@
+---
+description: Write a distilled state-of-play for this session and push it as a typed Jentrix artifact
+allowed-tools: Bash(jentrix push:*), Bash(jentrix session:*), Bash(jentrix task:*)
+---
+
+Write down what this session currently knows, and push it.
+
+This is the half a hook provably cannot do. A hook is a shell command with a
+small JSON payload on stdin and no model turn: it can move bytes and nothing
+else. Distilling 400k tokens into the six facts that mattered requires a model
+turn. That is this command.
+
+It matters most on a **capture-off** session, which is the MVP default. There
+the `PreCompact` hook records only that a compaction happened — it does not
+preserve the transcript, because `capture: "off"` means the operator asked for
+typed artifacts and no transcript. The bytes stay on the local machine and
+nothing carries their meaning into Jentrix unless you write it. So on a
+capture-off session this command is not a nicety; it is the only thing that
+survives the compaction.
+
+Run it at real boundaries: before a `/compact`, after a decision that changes
+the plan, when a long investigation resolves, or before handing the work over.
+
+## Steps
+
+1. Write the checkpoint. Cover only what a fresh session would need and could
+   not re-derive cheaply:
+   - **Decisions taken** — and, for each, the reason, because the reason is
+     what gets lost first.
+   - **What actually changed** — files, records, ids. Concrete, not "made
+     progress".
+   - **Open questions and dead ends** — including what was tried and did not
+     work, which is the most expensive thing to rediscover.
+   - **Next step** — the single thing to do next.
+2. Do not summarize the transcript. Do not restate the prompt. Do not include
+   anything you have not verified this session — a checkpoint that carries a
+   guess as a fact poisons every session that reads it.
+3. Push it:
+   - `jentrix push learning --title "Checkpoint — <topic>"` when it is durable
+     knowledge worth carrying past this project;
+   - `jentrix push report --title "Checkpoint — <topic>"` when it is the
+     state of THIS work.
+   Content goes on stdin.
+4. Relay the returned `artifactId` to the operator, and say which kind you
+   chose and why.
+5. If the session's task status no longer matches reality, fix it now:
+   `jentrix column list --board <boardId>` then
+   `jentrix task move --task <id> --to-column-id <id>`. Only the columns the
+   board actually has.
+
+Note for the operator: this records the distillation. On a session aligned
+with `--capture`, the raw pre-compaction range is preserved separately and
+automatically by the `PreCompact` hook, so the bytes survive even when this
+command is never run — but only the bytes. On a capture-off session (the MVP
+default) the hook records the boundary and nothing else, so this command is
+the only thing that carries the work forward.

package/claude-plugin/commands/jentrix-connect.md

@@ -0,0 +1,21 @@
+---
+description: Connect this Claude Code session to a Jentrix project (session anchor + capture)
+allowed-tools: Bash(jentrix session:*)
+---
+
+Run this exact command with the Bash tool and relay its output to the user:
+
+```
+jentrix session attach --provider claude --watch
+```
+
+Notes for you (the assistant):
+
+- Do NOT pass `--provider-session` yourself — the CLI reads the current
+  session id and transcript path from the TRUSTED lifecycle-hook context this
+  plugin's hooks recorded; model-authored session ids are never accepted.
+- If the user named a project (e.g. `/jentrix-connect atlas`), append
+  `--project <that value>`.
+- If the command fails, show its error verbatim — it names the fallback
+  (`jentrix session attach ...`) and the blocker code. Do not improvise a
+  workaround.

package/claude-plugin/commands/jentrix-end.md

@@ -0,0 +1,62 @@
+---
+description: End the connected Jentrix session (pushes the final artifacts, verifies capture, stores the RUN_SUMMARY)
+allowed-tools: Bash(jentrix session:*), Bash(jentrix push:*)
+---
+
+End the connected Jentrix session honestly. For an ALIGNED session (the MVP
+pipeline), the typed artifacts ARE the record — push them before closing:
+
+1. If this session is aligned (`jentrix session status` shows the alignment,
+   or `jentrix align --questions --json` reports `currentAlignment`):
+   - Push the final report: write a concise session report (what was done,
+     what changed, what's next) and run
+     `jentrix push report --title "<short title>"` with the content on stdin.
+   - Push any decisions made this session that were not already pushed:
+     `jentrix push decision …` (one per decision).
+   - Push any durable lessons: `jentrix push learning …`.
+   - If the session produced a diff/patch worth recording, push it:
+     `git diff | jentrix push diff --title "<what it changes>"`.
+   Ask the operator (native choice UI) before pushing anything they might
+   not want recorded; never invent content — summarize what actually
+   happened.
+2. Move the aligned task to the board's **"In review"** column when the work
+   is finished — not to a terminal one. Acceptance is a human's to record
+   (Accept / Return on the task panel writes who decided, when, and on which
+   artifacts), and an agent grading its own work as Done is the cheapest habit
+   to break now and the most expensive later. Read the board's real columns
+   first — `jentrix column list --board <boardId>` — and move with
+   `jentrix task move --task <taskId> --to-column-id <columnId>`. Use the
+   column names the board has; never invent a status it does not carry, and
+   never move a card whose work is unfinished. If the board has no in-review
+   column, say so and leave the card where it is rather than moving it to a
+   terminal column the operator never got to judge. If it is unclear whether
+   the task is done, ask the operator through the native choice UI. Pushing a
+   `findings` or `report` artifact is not by itself proof the task is done.
+3. **Offer a one-line project outcome.** A project that never changes state
+   cannot answer the only question a goal exists to answer — are we closer.
+   Ask the operator, through the native choice UI, for one sentence on what
+   this session moved, and record it on the project's goal statement: read the
+   project first — `jentrix tool get_project --args '{"projectId":"<id>"}'` —
+   then append a dated line to its `goalStatement` (never overwrite what is
+   there):
+   `jentrix tool update_project --args '{"projectId":"<id>","goalStatement":"<existing text>\n<YYYY-MM-DD>: <the operator's sentence>","expectedUpdatedAt":"<updatedAt from the read>"}'`.
+   Offer it; never write a sentence they did not say, and never block the
+   close on it — a declined nudge is a normal outcome.
+4. Run `jentrix session end <session-id>` with the Bash tool (ask the user or
+   run `jentrix session status` first when the id is unknown) and relay the
+   output. Telemetry is recorded by the session host's attested path — never
+   report token numbers yourself.
+5. **Relay the closing telemetry line verbatim.** `session end` prints a
+   `Telemetry:` line, and on stderr it may print `NO TOKEN TELEMETRY: …`.
+   Exit 0 does NOT mean telemetry was recorded — on 2026-08-11 a real session
+   closed at exit 0 having recorded none, and nothing said so. If the warning
+   appears, show it in full: it names the cause (usually the host was watching
+   another session's transcript) and the repair for the next session
+   (`jentrix align --provider-session <id> --transcript-path <file>`). Do not
+   restate the numbers as your own claim — quote the line.
+6. The session is SEALED once ended: `jentrix push` refuses it
+   (`SESSION_NOT_ACTIVE`), by design. Anything learned at the close —
+   including the telemetry line above — belongs in the report you pushed in
+   step 1, or in the next session. Do not try to reopen it.
+7. Ending the Jentrix session does NOT terminate this Claude Code session —
+   say so if the user seems to expect it.

package/claude-plugin/commands/jentrix-plan.md

@@ -0,0 +1,66 @@
+---
+description: Turn the opening prompt into a goal and a small set of Jentrix tasks, confirmed by the operator before anything is created
+allowed-tools: Bash(jentrix task:*), Bash(jentrix column:*), Bash(jentrix board:*), Bash(jentrix session:*), Bash(jentrix push:*)
+---
+
+Decompose the work the operator just asked for into a goal and a short task
+list, **confirm both before creating anything**, then create them.
+
+`/jentrix-align` binds at most ONE task and is scrupulous that its title is the
+operator's own words. Every task after that used to be agent-invented with no
+confirmation step at all — the principle was right and its coverage was one
+task deep. This command extends the same rule to the rest.
+
+## Rules that are not negotiable
+
+- **You never create a board-permanent title the operator has not approved.**
+  Propose; do not decide. The operator edits or replaces any title before it
+  is created.
+- **Propose few tasks.** A task is a commitment, not a restatement of the
+  prompt. Two or three real units of work beat six that mirror your plan's
+  headings. If the prompt is one unit of work, say so and create nothing.
+- **The prompt is provenance, the tasks are commitments.** Save the prompt
+  once, verbatim, as a `prompt` artifact; do not transcribe it into task
+  titles. The approved goal is its own `goal` artifact — the inputs are typed
+  records the RUN_SUMMARY's Intent cites, not prose folded into a plan.
+- Read the board's real columns before placing anything. Never invent a
+  column or a status.
+
+## Steps
+
+1. Confirm the session is aligned: `jentrix session status`. If it is not, stop
+   and point the operator at `/jentrix-align` — there is no project or board to
+   plan into, and creating tasks somewhere else is worse than creating none.
+2. Read the board's columns:
+   `jentrix column list --board <boardId> --json`. The first column is the
+   normal home for new work unless the operator says otherwise.
+3. Draft, in your own analysis and NOT yet on the board:
+   - **one goal sentence** — what "done" means for this work, and how it will
+     be judged;
+   - **1–4 task titles**, each a unit of work someone could pick up alone.
+4. Present them for confirmation through the native choice UI
+   (AskUserQuestion), one decision at a time, showing your proposed wording
+   verbatim. Note that the choice UI has no free-text-only mode — it requires
+   preset options — so "Other…" is the intended escape for the operator to
+   type their own wording, and you must say so. Their words win; when they
+   type a replacement, use it exactly, do not "clean it up".
+5. Create only what was approved:
+   - `jentrix task create --column-id <columnId> --title "<approved title>" --description "<one-line scope>" --idempotency-key "<stable-key>" --json`
+   - record the goal on the aligned task (the card keeps its at-a-glance
+     line; the artifact below is the record):
+     `jentrix task update --task <alignedTaskId> --description "GOAL: <approved goal> …"`
+   - push the opening prompt as provenance, VERBATIM:
+     `jentrix push prompt --title "Opening prompt"` with the operator's prompt
+     on stdin — never a paraphrase;
+   - push the approved goal:
+     `jentrix push goal --title "Goal"` with the approved goal sentence on
+     stdin;
+   - when a PRD exists for this work, push it too:
+     `jentrix push prd --title "<PRD title>"` with the PRD body on stdin.
+6. Report the created ids and keys back to the operator, and say which task
+   you are starting on. Move that one into the working column
+   (`jentrix task move --task <id> --to-column-id <id>`).
+
+If the operator declines the plan, create nothing and say so plainly. An
+un-decomposed prompt is a normal outcome; a board full of speculative tasks is
+not.

package/claude-plugin/commands/jentrix-status.md

@@ -0,0 +1,8 @@
+---
+description: Show the connected Jentrix session for this work (capture health included)
+allowed-tools: Bash(jentrix session:*)
+---
+
+Run `jentrix session status` with the Bash tool (append the session id if the
+user gave one) and relay the output verbatim, including any capture-pending
+warning.

package/claude-plugin/hooks/hooks.json

@@ -0,0 +1,57 @@
+{
+  "description": "M20.1 \u00a715.1 \u2014 lifecycle bridge: hooks append their structured stdin payload (session_id, transcript_path, cwd) to the local session context file via `stacks-runner session-hook`. argv carries only the directory and event name \u2014 never credentials or transcript content. PreCompact/PostCompact additionally run `jentrix session snapshot`, which FOLLOWS THE CAPTURE CONSENT: capture ON preserves the transcript range about to leave the model's context; capture OFF (the MVP default) records the compaction boundary and NO content, because `capture: \"off\"` was disclosed as typed artifacts only, no transcript. Preservation is never distillation \u2014 a hook has no model turn; /jentrix-checkpoint does that. Compaction-path hooks carry an explicit 10s timeout (STA-51): they run inside the operator's /compact, and a slow artifact push must delay it by seconds, not the 60s default.",
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "stacks-runner session-hook --dir \"$HOME/.config/stacks/claude-sessions\" --event SessionStart"
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "stacks-runner session-hook --dir \"$HOME/.config/stacks/claude-sessions\" --event SessionEnd"
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "stacks-runner session-hook --dir \"$HOME/.config/stacks/claude-sessions\" --event PreCompact",
+            "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "jentrix session snapshot --event PreCompact",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "PostCompact": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "stacks-runner session-hook --dir \"$HOME/.config/stacks/claude-sessions\" --event PostCompact",
+            "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "jentrix session snapshot --event PostCompact",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}

package/codex-plugin/.agents/plugins/marketplace.json

@@ -0,0 +1,20 @@
+{
+  "name": "jentrix",
+  "interface": {
+    "displayName": "Jentrix"
+  },
+  "plugins": [
+    {
+      "name": "jentrix",
+      "source": {
+        "source": "local",
+        "path": "./plugins/jentrix"
+      },
+      "policy": {
+        "installation": "AVAILABLE",
+        "authentication": "ON_INSTALL"
+      },
+      "category": "Productivity"
+    }
+  ]
+}

package/codex-plugin/plugins/jentrix/.codex-plugin/plugin.json

@@ -0,0 +1,26 @@
+{
+  "name": "jentrix",
+  "version": "0.1.0",
+  "description": "Connect Codex tasks to Jentrix projects with trusted lifecycle hooks, alignment, checkpoints, and honest session capture.",
+  "author": {
+    "name": "Jentrix",
+    "url": "https://github.com/jentrix-au"
+  },
+  "homepage": "https://stacks-mvp.vercel.app/docs",
+  "repository": "https://github.com/jentrix-au/task-manager",
+  "license": "MIT",
+  "keywords": ["jentrix", "sessions", "task-management", "agents"],
+  "skills": "./skills/",
+  "interface": {
+    "displayName": "Jentrix",
+    "shortDescription": "Connect this Codex task to Jentrix.",
+    "longDescription": "Align a Codex task to a Jentrix project and task, preserve typed checkpoints, and capture supported lifecycle evidence through trusted hooks.",
+    "developerName": "Jentrix",
+    "category": "Productivity",
+    "capabilities": ["Interactive", "Write"],
+    "defaultPrompt": [
+      "Connect this Codex task to my Jentrix project.",
+      "Align this work and create a confirmed task plan."
+    ]
+  }
+}

package/codex-plugin/plugins/jentrix/hooks/hooks.json

@@ -0,0 +1,87 @@
+{
+  "description": "Trusted Codex lifecycle bridge. Hook payloads are appended locally; compact hooks also ask the Jentrix CLI to preserve the approved capture boundary.",
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "stacks-runner session-hook --dir \"$HOME/.config/stacks/codex-sessions\" --event SessionStart"
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "stacks-runner session-hook --dir \"$HOME/.config/stacks/codex-sessions\" --event UserPromptSubmit"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "stacks-runner session-hook --dir \"$HOME/.config/stacks/codex-sessions\" --event PostToolUse"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "stacks-runner session-hook --dir \"$HOME/.config/stacks/codex-sessions\" --event Stop"
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "stacks-runner session-hook --dir \"$HOME/.config/stacks/codex-sessions\" --event PreCompact",
+            "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "jentrix session snapshot --event PreCompact",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "PostCompact": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "stacks-runner session-hook --dir \"$HOME/.config/stacks/codex-sessions\" --event PostCompact",
+            "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "jentrix session snapshot --event PostCompact",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "stacks-runner session-hook --dir \"$HOME/.config/stacks/codex-sessions\" --event SessionEnd"
+          }
+        ]
+      }
+    ]
+  }
+}

package/codex-plugin/plugins/jentrix/skills/jentrix-align/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: stacks-align
+description: Align the current Codex task to a Jentrix workspace, project, work item, and owner with an operator-confirmed server snapshot.
+---
+
+# Align this Codex task
+
+1. Run `jentrix align --provider codex --questions --json`.
+2. Relay every failed or warning precondition before asking anything.
+3. If `currentAlignment` exists, ask whether to keep it or re-align. Keep means
+   show the current snapshot and stop.
+4. Present each `status:"ask"` question and its choices verbatim using Codex's
+   structured input UI when available, otherwise ask in chat. Never answer for the
+   operator. Preserve notices and the `Other…` free-text escape.
+5. Re-run `--questions --json` after project selection. Collect `project_name` and
+   `task_title` as free text from the operator; never propose permanent names.
+6. Present the confirmation prompt and every disclosure verbatim.
+7. On confirmation, submit exactly once with `jentrix align --provider codex --json
+   --yes` plus the confirmed project, task/session-level, owner, agent label, and
+   capture flags.
+8. Echo the returned server alignment snapshot verbatim. If `.mcp.json` changed,
+   explain that the current task must reconnect MCP or restart before using it.
+
+TRACE capture is off by default. Pass `--capture` only when the operator explicitly
+approved full hook-derived trace capture. Same-project re-alignment converges;
+different-project re-alignment must be refused until `jentrix session end`.