arreio 1.1.0 → 1.2.0

package/skills/review/modules/prepare.md

@@ -90,7 +90,7 @@ Apply the **[phase confirmation behavior](../references/interaction-mode-propaga
 - **Smart:** pause only when a pause trigger above is true; otherwise auto-proceed.
 - **Autopilot:** auto-proceed (no confirmation).
 
-Then save the artifact to `docs/review/.prepare/<prepare-id>.md` (ensure `interactionMode` included) and return it, with the `interactionMode` value, to the Orchestrator for the transition to Phase 3 (Analyze).
+Then, **in `detailed` mode only**, save the artifact to `docs/review/.prepare/<prepare-id>.md` (ensure `interactionMode` included) and return it, with the `interactionMode` value, to the Orchestrator for the transition to Phase 3 (Analyze). In `smart` and `autopilot` mode, do **not** write the file; pass the artifact to the next phase in context (see [Artifact Persistence](../references/interaction-mode-propagation.md#artifact-persistence)).
 
 ## Output: Review Kit Artifact
 
@@ -98,6 +98,6 @@ Then save the artifact to `docs/review/.prepare/<prepare-id>.md` (ensure `intera
 - Verify that every `required` file has a diff entry (or is recorded as deleted / `current-contents`) and that `context` is separated from `required`.
 - Verify that `test-context` records covering tests per changed file and whether the change ships its own tests.
 - Verify that `requirements-source: none` propagated as `spec: none` (so Analyze skips the requirements-vs-scope-creep category rather than guessing).
-- Verify that the artifact is saved to `docs/review/.prepare/<prepare-id>.md`.
+- Verify that, in `detailed` mode, the artifact is saved to `docs/review/.prepare/<prepare-id>.md`; in `smart`/`autopilot` mode, verify that **no** file was written and the artifact was passed to the next phase in context.
 
 > Pass the Review Kit to `analyze` (Phase 3) for the categorized, severity-graded review of the diffs.

package/skills/review/modules/scope.md

@@ -89,7 +89,7 @@ Search `docs/learn/index.md` for entries relevant to the review domains (the cha
 
 ### Step 6: Allocate review-id and Generate the Review Scope Artifact
 
-1. **Allocate a `review-id`** of the form `YYYY-MM-DD-NNN` per [id-generation.md](../references/id-generation.md), counting existing `docs/review/.scope/YYYY-MM-DD-NNN-scope.md` files (or registry rows) for today. This is the pipeline umbrella id (distinct from any Work `review-id` for work-linked input — the two skills produce independent artifacts; the `work-id` is carried alongside for traceability).
+1. **Allocate a `review-id`** of the form `YYYY-MM-DD-NNN` per [id-generation.md](../references/id-generation.md), counting existing `docs/review/.scope/YYYY-MM-DD-NNN-scope.md` files (or registry rows) for today in `detailed` mode, or existing `docs/review/.report/` files in `smart`/`autopilot` (no scope file is written; see id-generation.md). This is the pipeline umbrella id (distinct from any Work `review-id` for work-linked input — the two skills produce independent artifacts; the `work-id` is carried alongside for traceability).
 
 2. **Assign a `scope-id`** per [id-generation.md](../references/id-generation.md) (format `YYYY-MM-DD-NNN-scope`, saved to `docs/review/.scope/`). Reuse it if the user later picks **Edit & Retry**.
 
@@ -113,7 +113,7 @@ Apply the **[phase confirmation behavior](../references/interaction-mode-propaga
 - **Smart:** pause only when a pause trigger above is true; otherwise auto-proceed.
 - **Autopilot:** auto-proceed (no confirmation).
 
-Then save the artifact to `docs/review/.scope/<scope-id>.md` (ensure `interactionMode`, `input-shape`, and `review-id` are included) and return it, with the `interactionMode` value, to the Orchestrator for the transition to Phase 2 (Prepare).
+Then, **in `detailed` mode only**, save the artifact to `docs/review/.scope/<scope-id>.md` (ensure `interactionMode`, `input-shape`, and `review-id` are included) and return it, with the `interactionMode` value, to the Orchestrator for the transition to Phase 2 (Prepare). In `smart` and `autopilot` mode, do **not** write the file; pass the artifact to the next phase in context (see [Artifact Persistence](../references/interaction-mode-propagation.md#artifact-persistence)).
 
 ## Output: Review Scope Artifact
 
@@ -121,6 +121,6 @@ Then save the artifact to `docs/review/.scope/<scope-id>.md` (ensure `interactio
 - Verify that the change boundary is in **dependency-safe** form: `required` files are repository-relative and carry a status; `context` is separated from `required`.
 - Verify that `review-id` was allocated (scope is the allocating phase) and that `work-id` is carried for work-linked input.
 - Verify that scope-creep detection was run only when requirements were present (else explicitly skipped with a note), per [scope-creep-detection.md](../references/scope-creep-detection.md).
-- Verify that the artifact is saved to `docs/review/.scope/<scope-id>.md`.
+- Verify that, in `detailed` mode, the artifact is saved to `docs/review/.scope/<scope-id>.md`; in `smart`/`autopilot` mode, verify that **no** file was written and the artifact was passed to the next phase in context.
 
 > Pass the Review Scope to `prepare` (Phase 2) to gather the diffs, spec content, test context, and tool inventory.

package/skills/review/references/id-generation.md

@@ -12,7 +12,7 @@ Shared ID algorithm for the `scope`, `prepare`, `analyze`, and `report` phases,
 
 ## ID Format by Phase
 
-| Phase    | ID format                            | Saved to                            |
+| Phase    | ID format                            | Saved to (detailed only)                            |
 | -------- | ----------------------------------- | ----------------------------------- |
 | Scope    | `YYYY-MM-DD-NNN-scope`              | `docs/review/.scope/<id>.md`    |
 | Prepare  | `YYYY-MM-DD-NNN-prepare`            | `docs/review/.prepare/<id>.md`  |
@@ -29,6 +29,8 @@ The `review-id` is the umbrella key that ties all four phase artifacts together
 
 > **Distinct from a Work `review-id`.** When Review is invoked over a `/work` run (`input-shape: work-linked`), the Work skill's own `review-id` (`docs/plans/.work/.review/...`) **already exists**. The Review skill allocates its **own** `review-id` (`docs/review/...`) — the two skills produce independent artifacts and never share an id. The `work-id` is carried alongside in the Review artifacts for traceability and the work-index cross-link, but `review-id` ≠ Work `review-id`.
 
+> **Persistence by mode.** The "Saved to" column and the directory-listing algorithm below apply **only in `detailed` mode**. In `smart`/`autopilot` mode phase artifacts are not written, so no directory is listed: Allocate `review-id` NNN by counting today's files in `docs/review/.report/` (+1); `scope-id`/`prepare-id`/`analyze-id` reuse that NNN as in-memory labels. See [Artifact Persistence](interaction-mode-propagation.md#artifact-persistence).
+
 ## Algorithm (new phase artifact)
 
 ```

package/skills/review/references/interaction-mode-propagation.md

@@ -77,4 +77,24 @@ Review deliberately has **no** `executionMode`:
 | Invalid mode value          | Reject; re-prompt Orchestrator        |
 | Artifact missing mode field | Assume "smart"; log warning; continue |
 | User selects "Abort"        | Stop immediately; inform Orchestrator |
-| Timeout/connection lost     | Pause; ask user to retry or abort     |
+| Timeout/connection lost     | Pause; ask user to retry or abort     |
+
+## Artifact Persistence
+
+Phase artifacts (Scope, Prepare, Analyze) are **handoff data between phases**, not deliverables. Whether they are written to disk depends on `interactionMode`:
+
+| Mode          | Phase artifacts (`docs/review/.scope/`, `.prepare/`, `.analyze/`)          | Phase handoff                                  |
+| ------------- | ---------------------------------------- | ---------------------------------------------- |
+| **Detailed**  | Written to the hidden directories (audit trail; creating the directory on first use) | Artifact is written, shown, then passed on     |
+| **Smart**     | **Not written**                          | Artifact is held in context and passed in-memory to the next phase |
+| **Autopilot** | **Not written**                          | Artifact is held in context and passed in-memory to the next phase |
+
+**Always written, in every mode:** the Review Report in `docs/review/.report/<report-id>.md` and its row in `docs/review/index.md` (a cross-skill handoff read by `/learn`).
+
+**Rules:**
+
+- The artifact schema, quality gates, cross-phase ID checks, and pause triggers are **unchanged** — only the disk write is skipped. Validate and pass the in-memory artifact exactly as you would the file.
+- Never create the hidden directories in `smart`/`autopilot`; no placeholder or empty files.
+- **ID allocation without files:** Allocate `review-id` NNN by counting today's files in `docs/review/.report/` (+1); `scope-id`/`prepare-id`/`analyze-id` reuse that NNN as in-memory labels.
+- If the user switches to `detailed` mid-run, write the artifacts produced so far, then continue writing.
+- Because nothing is on disk, **Edit & Retry** reuses the in-memory artifact and its id (no file to overwrite).

package/skills/review/references/templates/artifacts/findings.md

@@ -53,7 +53,7 @@ scope-creep-ran: true | "skipped (no requirements)"   # false only via the skipp
 work-id: YYYY-MM-DD-NNN | null          # work-linked only; null otherwise
 ```
 
-Also save the Findings to `docs/review/.analyze/<analyze-id>.md`.
+In `detailed` mode only, also save the Findings to `docs/review/.analyze/<analyze-id>.md`. In `smart`/`autopilot` mode, do not write it; pass it to the next phase in context.
 
 ## Validation Rules
 

package/skills/review/references/templates/artifacts/review-kit.md

@@ -60,7 +60,7 @@ tool-inventory:
 work-id: YYYY-MM-DD-NNN | null    # work-linked only; null otherwise
 ```
 
-Also save the Review Kit to `docs/review/.prepare/<prepare-id>.md`.
+In `detailed` mode only, also save the Review Kit to `docs/review/.prepare/<prepare-id>.md`. In `smart`/`autopilot` mode, do not write it; pass it to the next phase in context.
 
 ## Validation Rules
 

package/skills/review/references/templates/artifacts/review-scope.md

@@ -56,7 +56,7 @@ learning-gaps:
 work-id: YYYY-MM-DD-NNN | null             # work-linked only, for the index cross-link; null otherwise
 ```
 
-Also save the Review Scope to `docs/review/.scope/<scope-id>.md`.
+In `detailed` mode only, also save the Review Scope to `docs/review/.scope/<scope-id>.md`. In `smart`/`autopilot` mode, do not write it; pass it to the next phase in context.
 
 ## Validation Rules
 

package/skills/work/SKILL.md

@@ -35,6 +35,8 @@ Store in the context object:
 interactionMode: detailed | smart | autopilot
 ```
 
+**Artifact persistence:** intermediate phase artifacts are written to disk **only in `detailed` mode**. In `smart`/`autopilot` they are passed between phases in context and never written (see `references/interaction-mode-propagation.md#artifact-persistence`). Final deliverables are always written.
+
 **Propagation:** `interactionMode` flows into the `triage`, `prepare`, `execute`, and `review` artifacts; each downstream phase reads it to adjust confirmation behaviour (detailed = pause every transition; autopilot = run all; smart = pause only on HIGH-risk).
 
 > **Interaction mode is distinct from execution mode.** `interactionMode` governs _when to pause for the user_ (the same three modes as the `/plan` skill). **Execution mode** (inline / serial / parallel) governs _how multiple tasks are run_ and is selected in the Prepare phase. The two are carried independently through the pipeline.
@@ -59,7 +61,8 @@ Each phase runs sequentially: the orchestrator calls the phase module, receives
 Before starting the work pipeline, the orchestrator verifies that required folders exist:
 
 - `docs/tasks/` — must exist for reading (plan-based) or creating (ad-hoc) the task list
-- `docs/plans/.work/.triage/`, `docs/plans/.work/.prepare/`, `docs/plans/.work/.execute/`, `docs/plans/.work/.review/` — must exist for saving the four phase artifacts
+- `docs/plans/.work/.review/` — must exist for saving the Work Report (always written)
+- `docs/plans/.work/.triage/`, `docs/plans/.work/.prepare/`, `docs/plans/.work/.execute/` — **`detailed` mode only**, for saving the intermediate phase artifacts; do not create them in `smart`/`autopilot`
 
 **Self-Healing:** If any are missing, the orchestrator automatically creates them (`mkdir -p`). This allows the work skill to run even if `arreio-init` wasn't explicitly run.
 
@@ -82,9 +85,9 @@ Every new feature or plan runs on its own git branch:
 
 | Phase | Phase Module                  | Output Artifact                                                    | Saved to                            |
 | ----- | ----------------------------- | ------------------------------------------------------------------ | ----------------------------------- |
-| 1     | [Triage](modules/triage.md)   | [Work manifest](references/templates/artifacts/work-manifest.md) + `work/<slug>` branch | `docs/plans/.work/.triage/<id>.md`  |
-| 2     | [Prepare](modules/prepare.md) | [Execution plan](references/templates/artifacts/execution-plan.md) | `docs/plans/.work/.prepare/<id>.md` |
-| 3     | [Execute](modules/execute.md) | [Execution log](references/templates/artifacts/execution-log.md)   | `docs/plans/.work/.execute/<id>.md` |
+| 1     | [Triage](modules/triage.md)   | [Work manifest](references/templates/artifacts/work-manifest.md) + `work/<slug>` branch | `docs/plans/.work/.triage/<id>.md` _(detailed only)_ |
+| 2     | [Prepare](modules/prepare.md) | [Execution plan](references/templates/artifacts/execution-plan.md) | `docs/plans/.work/.prepare/<id>.md` _(detailed only)_ |
+| 3     | [Execute](modules/execute.md) | [Execution log](references/templates/artifacts/execution-log.md)   | `docs/plans/.work/.execute/<id>.md` _(detailed only)_ |
 | 4     | [Review](modules/review.md)   | [Work report](references/templates/artifacts/work-report.md)       | `docs/plans/.work/.review/<id>.md`  |
 
 ### Quality Gates
@@ -143,6 +146,17 @@ Artifact templates live in [references/templates/artifacts/](references/template
 | [execution-log.md](references/templates/artifacts/execution-log.md)   | Execute      |
 | [work-report.md](references/templates/artifacts/work-report.md)       | Review       |
 
+## Execution Rules
+
+Follow these literally; they exist to keep runs consistent across agents.
+
+1. **Run each module's steps in order**, starting with its Step 0 verification. Do not skip, merge, or reorder steps.
+2. **Never invent values.** If a required input is missing, apply the recovery in [error-handling.md](references/error-handling.md) or ask the user; do not fill it with a plausible guess.
+3. **Compute, don't copy.** Values defined by an algorithm or reference (`executionMode`, per-task risk floor, task status transitions, baseline result) must be evaluated with the real inputs; a recommendation is never `serial` just because it is the fallback. Example values in references and templates are illustrations, never defaults.
+4. **One question at a time**, with 2–4 concrete options; build the question text from the current values.
+5. **Announce phase transitions in one line** (e.g., "Phase 2/4 Prepare complete: <key result>") so the user can follow progress, even in Autopilot.
+6. **Honor write rules:** intermediate phase artifacts only in `detailed` mode; final deliverables always.
+
 ## Core Principles
 
 - **Deterministic Pipeline:** Phases always execute in sequence (no agent switching, no fallback paths).
@@ -156,6 +170,7 @@ Artifact templates live in [references/templates/artifacts/](references/template
 - **Error Handling:** Fail explicitly, not silently; each phase has clear error handling with recovery suggestions.
 - **Be Concrete:** Use specific files, components, and dependencies from the task artifacts.
 - **Stay Portable:** Use repository-relative paths only.
+- **Lean Persistence:** Phase artifacts hit disk only in `detailed` mode; `smart`/`autopilot` pass them in context to save tokens and time.
 - **Transparent Artifacts:** Each phase produces an explicit output artifact for the next phase.
 - **Interaction Mode Propagation:** `interactionMode` is read at the start of each subsequent phase and determines whether confirmation steps execute.
 - **Single Source of Truth:** This skill defines all its own rules; it does not depend on any external agent rule file.

package/skills/work/modules/execute.md

@@ -95,7 +95,7 @@ Apply the **[phase confirmation behavior](../references/interaction-mode-propaga
 - **Smart:** pause only when a pause trigger above is true; otherwise auto-proceed.
 - **Autopilot:** auto-proceed (no confirmation).
 
-Then save the artifact to `docs/plans/.work/.execute/<execute-id>.md` (ensure `interactionMode` and `executionMode` are included) and return it, with both mode values, to the Orchestrator for the transition to Phase 4 (Review).
+Then, **in `detailed` mode only**, save the artifact to `docs/plans/.work/.execute/<execute-id>.md` (ensure `interactionMode` and `executionMode` are included) and return it, with both mode values, to the Orchestrator for the transition to Phase 4 (Review). In `smart` and `autopilot` mode, do **not** write the file; pass the artifact to the next phase in context (see [Artifact Persistence](../references/interaction-mode-propagation.md#artifact-persistence)).
 
 ## Output: Execution Log Artifact
 
@@ -104,6 +104,6 @@ Then save the artifact to `docs/plans/.work/.execute/<execute-id>.md` (ensure `i
 - Verify that each `completed` task has its `## Acceptance Criteria` checkbox flipped to `- [x]` and the index ticked `- [ ] → - [x]` (forward only — never reset).
 - Verify that every `completed` task's single AC test is green with no new regression beyond the recorded baseline snapshot.
 - Verify that the gate/transition behavior was **enforced from** [task-execution-rules.md](../references/task-execution-rules.md) and [execution-mode-selection.md](../references/execution-mode-selection.md) rather than re-defined inline.
-- Verify that the artifact is saved to `docs/plans/.work/.execute/<execute-id>.md`.
+- Verify that, in `detailed` mode, the artifact is saved to `docs/plans/.work/.execute/<execute-id>.md`; in `smart`/`autopilot` mode, verify that **no** file was written and the artifact was passed to the next phase in context.
 
 > Pass the Execution Log to `review` (Phase 4) for the simplification, consolidation, and learnings-capture pass.

package/skills/work/modules/prepare.md

@@ -79,7 +79,7 @@ Select how `execution-list` is run. The three modes are defined canonically in *
 1. **Compute the default** from the table above, reading each task's `priority` and any HIGH-risk flag carried from the manifest.
 2. **Apply the risk floor (authoritative in [execution-mode-selection.md](../references/execution-mode-selection.md)):** any HIGH-risk task forces `inline` for that task; the user may not downgrade a HIGH-risk task below `inline`.
 3. **Determine user preference:**
-   - **Detailed:** ask the user which mode to run, presenting the recommendation.
+   - **Detailed:** ask the user which mode to run using the question template in [execution-mode-selection.md](../references/execution-mode-selection.md), filled with the computed values (including `Auto`).
    - **Smart:** auto-select, unless a pause trigger fires (Step 7).
    - **Autopilot:** auto-select; never ask.
 4. **Honor user preference** unless it violates the risk floor; on violation, ask the user to accept `inline` instead.
@@ -126,7 +126,7 @@ Apply the **[phase confirmation behavior](../references/interaction-mode-propaga
 - **Smart:** pause only when a pause trigger above is true; otherwise auto-proceed.
 - **Autopilot:** auto-proceed (no confirmation).
 
-Then save the artifact to `docs/plans/.work/.prepare/<prepare-id>.md` (ensure `interactionMode` and `executionMode` are included) and return it, with both mode values, to the Orchestrator for the transition to Phase 3 (Execute).
+Then, **in `detailed` mode only**, save the artifact to `docs/plans/.work/.prepare/<prepare-id>.md` (ensure `interactionMode` and `executionMode` are included) and return it, with both mode values, to the Orchestrator for the transition to Phase 3 (Execute). In `smart` and `autopilot` mode, do **not** write the file; pass the artifact to the next phase in context (see [Artifact Persistence](../references/interaction-mode-propagation.md#artifact-persistence)).
 
 ## Output: Execution Plan Artifact
 
@@ -135,6 +135,6 @@ Then save the artifact to `docs/plans/.work/.prepare/<prepare-id>.md` (ensure `i
 - Verify that the gate/policy details were **read from** [task-execution-rules.md](../references/task-execution-rules.md) rather than re-encoded inline (no second formula contradicting the authoritative reference).
 - Verify that `execution-list` preserves the manifest's dependency order (no task before its dependencies) and that wave-grouping (if `parallel`) respects dependency layers.
 - Verify that the `baseline` policy is recorded (a red baseline was surfaced, not hidden).
-- Verify that the artifact is saved to `docs/plans/.work/.prepare/<prepare-id>.md`.
+- Verify that, in `detailed` mode, the artifact is saved to `docs/plans/.work/.prepare/<prepare-id>.md`; in `smart`/`autopilot` mode, verify that **no** file was written and the artifact was passed to the next phase in context.
 
 > Pass the Execution Plan to `execute` (Phase 3) for the test-first execution run.

package/skills/work/modules/triage.md

@@ -166,7 +166,7 @@ Apply the **[phase confirmation behavior](../references/interaction-mode-propaga
 - **Smart:** pause only when a pause trigger above is true; otherwise auto-proceed.
 - **Autopilot:** auto-proceed (no confirmation).
 
-Then save the artifact to `docs/plans/.work/.triage/<triage-id>.md` (ensure `interactionMode` and `input-shape` are included) and return it, with the `interactionMode` value, to the Orchestrator for the transition to Phase 2 (Prepare).
+Then, **in `detailed` mode only**, save the artifact to `docs/plans/.work/.triage/<triage-id>.md` (ensure `interactionMode` and `input-shape` are included) and return it, with the `interactionMode` value, to the Orchestrator for the transition to Phase 2 (Prepare). In `smart` and `autopilot` mode, do **not** write the file; pass the artifact to the next phase in context (see [Artifact Persistence](../references/interaction-mode-propagation.md#artifact-persistence)).
 
 ## Output: Work Manifest Artifact
 
@@ -176,6 +176,6 @@ Then save the artifact to `docs/plans/.work/.triage/<triage-id>.md` (ensure `int
 - Verify that `work-id` is correct for the shape (inherited `plan-id` for plan-based/task-file; freshly allocated for ad-hoc).
 - Verify that `work-branch` is recorded in the manifest and, unless `null`, the repository is checked out on that branch.
 - Verify that for `ad-hoc` input, the task files and `docs/tasks/<work-id>/index.md` were created.
-- Verify that the artifact is saved to `docs/plans/.work/.triage/<triage-id>.md`.
+- Verify that, in `detailed` mode, the artifact is saved to `docs/plans/.work/.triage/<triage-id>.md`; in `smart`/`autopilot` mode, verify that **no** file was written and the artifact was passed to the next phase in context.
 
 > Pass the Work Manifest to `prepare` (Phase 2) for execution-mode selection and sequencing.

package/skills/work/references/execution-mode-selection.md

@@ -2,8 +2,8 @@
 title: Execution Mode Selection
 description: Authoritative reference for the Prepare phase. Defines the three execution modes (inline/serial/parallel), their selection defaults, the risk floor (HIGH-risk forces inline, non-downgradable), and the per-mode flows Execute follows.
 type: reference
-version: 1.0
-timestamp: "2026-08-07"
+version: 1.1
+timestamp: "2026-10-01"
 ---
 
 # Execution Mode Selection
@@ -41,6 +41,25 @@ Authoritative reference for the **Prepare** phase (Step 3). Defines the three ex
      parallel  -> waves: [Wave0, Wave1, ...]
 ```
 
+**Evaluation rules:**
+
+- The `default_mode` branches are checked **in the order written**; the first match wins. `serial` is the result **only** when neither earlier branch matches — it is a fallback, not a neutral default.
+- Evaluate with the real manifest data (task count, priorities, HIGH-risk flags, wave count). Do not copy a mode from an example.
+- The recommendation shown to the user is `default_mode` after the risk floor.
+
+**Detailed-mode question** — build it from computed values; replace every `<…>`:
+
+```
+This run has <N> tasks in <W> wave(s); <H> HIGH-risk, <P0> P0. I recommend <default_mode>.
+Which execution mode would you like?
+  - Inline: one task at a time, pause between tasks
+  - Serial: ordered list, no per-task pause
+  - Parallel: concurrent waves
+  - Auto: use the recommendation (result: <default_mode>)
+```
+
+Append ` [Recommended]` to the option equal to `default_mode`; if the risk floor makes an option unsafe, say so on that option.
+
 ## Risk Floor (authoritative, non-downgradable)
 
 - **Any HIGH-risk task forces `inline` treatment for that task**, regardless of the selected `executionMode`.

package/skills/work/references/id-generation.md

@@ -12,7 +12,7 @@ Shared ID algorithm for the `triage`, `prepare`, `execute`, and `review` phases,
 
 ## ID Format by Phase
 
-| Phase    | ID format                            | Saved to                         |
+| Phase    | ID format                            | Saved to (detailed only)                         |
 | -------- | ----------------------------------- | -------------------------------- |
 | Triage   | `YYYY-MM-DD-NNN-triage`             | `docs/plans/.work/.triage/<id>.md`   |
 | Prepare  | `YYYY-MM-DD-NNN-prepare`            | `docs/plans/.work/.prepare/<id>.md`  |
@@ -35,6 +35,8 @@ The `work-id` is the key that ties all four phase artifacts together and locates
 
 > **Work branch name:** the git branch for a run is `work/<short-description>` — a kebab-case slug derived from the plan name or work description (Triage Step 2d), **not** the `work-id` itself. The Work Manifest records the `work-branch` ↔ `work-id` pairing; see `skills/work/modules/triage.md` Step 2d.
 
+> **Persistence by mode.** The "Saved to" column and the directory-listing algorithm below apply **only in `detailed` mode**. In `smart`/`autopilot` mode phase artifacts are not written, so no directory is listed: Triage/Prepare/Execute ids are `<work-id>-<phase>` (in-memory labels). Only the Work Report `review-id` is persisted, so it still counts existing files in `docs/plans/.work/.review/`. See [Artifact Persistence](interaction-mode-propagation.md#artifact-persistence).
+
 ## Algorithm (new phase artifact)
 
 ```

package/skills/work/references/interaction-mode-propagation.md

@@ -77,4 +77,24 @@ The two never override one another; the orchestrator's quality gate #2 cross-che
 | Invalid mode value          | Reject; re-prompt Orchestrator        |
 | Artifact missing mode field | Assume "smart"; log warning; continue |
 | User selects "Abort"        | Stop immediately; inform Orchestrator |
-| Timeout/connection lost     | Pause; ask user to retry or abort     |
+| Timeout/connection lost     | Pause; ask user to retry or abort     |
+
+## Artifact Persistence
+
+Phase artifacts (Triage, Prepare, Execute) are **handoff data between phases**, not deliverables. Whether they are written to disk depends on `interactionMode`:
+
+| Mode          | Phase artifacts (`docs/plans/.work/.triage/`, `.prepare/`, `.execute/`)          | Phase handoff                                  |
+| ------------- | ---------------------------------------- | ---------------------------------------------- |
+| **Detailed**  | Written to the hidden directories (audit trail; creating the directory on first use) | Artifact is written, shown, then passed on     |
+| **Smart**     | **Not written**                          | Artifact is held in context and passed in-memory to the next phase |
+| **Autopilot** | **Not written**                          | Artifact is held in context and passed in-memory to the next phase |
+
+**Always written, in every mode:** the Work Report in `docs/plans/.work/.review/<review-id>.md` (a cross-skill handoff read by `/review` and `/learn`), the task files/index in `docs/tasks/<work-id>/`, and the work branch.
+
+**Rules:**
+
+- The artifact schema, quality gates, cross-phase ID checks, and pause triggers are **unchanged** — only the disk write is skipped. Validate and pass the in-memory artifact exactly as you would the file.
+- Never create the hidden directories in `smart`/`autopilot`; no placeholder or empty files.
+- **ID allocation without files:** Triage/Prepare/Execute ids are `<work-id>-<phase>` (in-memory labels). Only the Work Report `review-id` is persisted, so it still counts existing files in `docs/plans/.work/.review/`.
+- If the user switches to `detailed` mid-run, write the artifacts produced so far, then continue writing.
+- Because nothing is on disk, **Edit & Retry** reuses the in-memory artifact and its id (no file to overwrite).

package/skills/work/references/templates/artifacts/execution-log.md

@@ -52,7 +52,7 @@ final-index-state:
   uncompleted-rows: [<task-id>, ...]       # rows still - [] (blocked/skipped)
 ```
 
-Also save the Execution Log to `docs/plans/.work/.execute/<execute-id>.md`.
+In `detailed` mode only, also save the Execution Log to `docs/plans/.work/.execute/<execute-id>.md`. In `smart`/`autopilot` mode, do not write it; pass it to the next phase in context.
 
 ## Validation Rules
 

package/skills/work/references/templates/artifacts/execution-plan.md

@@ -55,7 +55,7 @@ policy:                                  # recorded read-only from task-executio
 work-state: ready | nothing-ready         # echoes the Work Manifest if carried through
 ```
 
-Also save the Execution Plan to `docs/plans/.work/.prepare/<prepare-id>.md`.
+In `detailed` mode only, also save the Execution Plan to `docs/plans/.work/.prepare/<prepare-id>.md`. In `smart`/`autopilot` mode, do not write it; pass it to the next phase in context.
 
 ## Validation Rules
 

package/skills/work/references/templates/artifacts/work-manifest.md

@@ -56,7 +56,7 @@ dependency-warning: null | proceeded-without-upstream | expanded-to-upstream   #
 work-state: ready | nothing-ready              # nothing-ready if no task is runnable
 ```
 
-Also save the manifest to `docs/plans/.work/.triage/<triage-id>.md` for future reference or reuse.
+In `detailed` mode only, also save the manifest to `docs/plans/.work/.triage/<triage-id>.md` for future reference or reuse. In `smart`/`autopilot` mode, do not write it; pass it to the next phase in context.
 
 ## Validation Rules