opencode-codeops 1.8.1 → 1.10.0

package/plugin/index.ts

@@ -4,6 +4,20 @@ import { homedir } from "node:os"
 import { join, dirname } from "node:path"
 import { fileURLToPath } from "node:url"
 
+import {
+  cleanStaleTmpDirs,
+  ensureSessionTmpDir,
+  removeSessionTmpDir,
+} from "../bin/lib/tmp-hygiene.mjs"
+import {
+  applyEffort,
+  findEffortMarker,
+  readRoutingReasoning,
+  readSessionEffort,
+  resolveEffort,
+} from "../bin/lib/reasoning-effort.mjs"
+import type { EffortLevel } from "../bin/lib/reasoning-effort.mjs"
+
 // ---------------------------------------------------------------------------
 // Package root — resolved at module load time so it is always the plugin's
 // installed directory, regardless of the working directory at event time.
@@ -43,6 +57,28 @@ const outputStyle = readFileSync(
 )
 const standardsText = `${codingStandards}\n\n${outputStyle}`
 
+// ---------------------------------------------------------------------------
+// Workspace hygiene — the plugin owns one temp directory per session (exported
+// as CODEOPS_TMPDIR) and sweeps directories abandoned by earlier interrupted
+// runs. The sweep runs at most once per plugin process, so spawning many child
+// sessions does not repeat the directory walk.
+// ---------------------------------------------------------------------------
+let sweptStaleTmpDirs = false
+
+/**
+ * Sweep temp directories abandoned by earlier interrupted runs, once per
+ * process. Cleanup is best effort: a failure must never block a session.
+ */
+function sweepStaleTmpDirsOnce(): void {
+  if (sweptStaleTmpDirs) return
+  sweptStaleTmpDirs = true
+  try {
+    cleanStaleTmpDirs()
+  } catch {
+    // Best effort only.
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Helper — inject standards into a session without triggering an AI reply.
 // Uses client.session.prompt with noReply: true (confirmed from OpenCode SDK).
@@ -109,23 +145,69 @@ async function warnOnVersionSkew(
   }
 }
 
+// ---------------------------------------------------------------------------
+// Helper — log one content-free warning. Logging is best effort: a failed log
+// must never break a request.
+// ---------------------------------------------------------------------------
+async function warnContentFree(
+  client: Parameters<Plugin>[0]["client"],
+  message: string
+): Promise<void> {
+  try {
+    await client.app.log({ body: { service: "codeops", level: "warn", message } })
+  } catch {
+    // Best effort only.
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helper — read the project routing config fresh on every request, so an edit
+// applies without restarting the session. Any failure means "no routing".
+// ---------------------------------------------------------------------------
+function readRoutingConfig(directory: string): unknown {
+  try {
+    return JSON.parse(readFileSync(join(directory, "codeops", "codeops.json"), "utf8"))
+  } catch {
+    return {}
+  }
+}
+
 // ---------------------------------------------------------------------------
 // CodeOps plugin for OpenCode
 // Replaces: hooks/hooks.json + hook_session_context.sh + hook_marker_guard.sh
 // ---------------------------------------------------------------------------
 export const CodeOpsPlugin: Plugin = async ({ client, directory }) => {
+  // Reasoning-effort state lives for the lifetime of this plugin instance:
+  // one entry per user message that carried a dispatch marker, plus a
+  // deduplication set for unsupported-level warnings.
+  const effortMarkers = new Map<string, { sessionID: string; level: EffortLevel }>()
+  const warnedEffortLevels = new Set<string>()
+
   return {
     // -----------------------------------------------------------------------
     // Hook 1 & 2: inject standards on session.created and session.compacted.
     // Both are dispatched via the generic event hook.
     // session.created  → new session    (Codex: startup)
     // session.compacted → after compact  (Codex: resume|compact)
+    // Also the hygiene lifecycle: a new top-level session sweeps abandoned
+    // temp directories once, and a deleted session's temp directory is removed.
     // -----------------------------------------------------------------------
     event: async ({ event }) => {
       if (event.type === "session.created") {
-        const sessionId: string = (event.properties as { info: { id: string } }).info.id
-        await injectStandards(client, sessionId)
+        const info = (event.properties as { info: { id: string; parentID?: string } }).info
+        await injectStandards(client, info.id)
         await warnOnVersionSkew(client, directory)
+        if (!info.parentID) sweepStaleTmpDirsOnce()
+      } else if (event.type === "session.deleted") {
+        const info = (event.properties as { info: { id: string } }).info
+        removeSessionTmpDir(info.id)
+        try {
+          for (const [messageID, entry] of effortMarkers) {
+            if (entry.sessionID === info.id) effortMarkers.delete(messageID)
+          }
+        } catch {
+          await warnContentFree(client, "Could not clear captured reasoning-effort markers.")
+        }
       } else if (event.type === "session.compacted") {
         const sessionId: string = (event.properties as { sessionID: string }).sessionID
         await injectStandards(client, sessionId)
@@ -148,9 +230,16 @@ export const CodeOpsPlugin: Plugin = async ({ client, directory }) => {
     // scripts as: python3 "${CODEOPS_PLUGIN_ROOT}/scripts/codeops_plan.py"
     // The value is the package root (parent of this plugin/ directory), which
     // is where skills/, scripts/, and the other shipped assets live.
+    // CODEOPS_TMPDIR is the session's directory under the CodeOps temp root;
+    // skills and agents put every scratch file there and delete it when done.
     // -----------------------------------------------------------------------
-    "shell.env": async (_input, output) => {
+    "shell.env": async (input, output) => {
       output.env.CODEOPS_PLUGIN_ROOT = PACKAGE_ROOT
+      try {
+        output.env.CODEOPS_TMPDIR = ensureSessionTmpDir(input.sessionID)
+      } catch {
+        // Best effort: a temp-directory failure must never block a shell.
+      }
     },
 
     // -----------------------------------------------------------------------
@@ -177,5 +266,59 @@ export const CodeOpsPlugin: Plugin = async ({ client, directory }) => {
         )
       }
     },
+
+    // -----------------------------------------------------------------------
+    // Hook 6: capture a dispatch marker from an incoming user message. The
+    // marker travels in the dispatch packet text; storing it by message id
+    // lets the later chat.params hook apply it to the same request.
+    // -----------------------------------------------------------------------
+    "chat.message": async (input, output) => {
+      try {
+        const texts = output.parts.map((part) =>
+          part?.type === "text" ? part.text : undefined
+        )
+        const level = findEffortMarker(texts)
+        if (level !== undefined) {
+          effortMarkers.set(output.message.id, { sessionID: input.sessionID, level })
+        }
+      } catch {
+        await warnContentFree(client, "Could not scan a message for a reasoning-effort marker.")
+      }
+    },
+
+    // -----------------------------------------------------------------------
+    // Hook 7: resolve the request's reasoning level (dispatch marker, then
+    // session flag, then routing default) and merge the model's own variant
+    // options. Any failure leaves the request unchanged.
+    // -----------------------------------------------------------------------
+    "chat.params": async (input, output) => {
+      try {
+        const stored = effortMarkers.get(input.message.id)
+        const marker = stored && stored.sessionID === input.sessionID ? stored.level : undefined
+        const session = readSessionEffort(input.sessionID)
+        const routing = readRoutingReasoning(readRoutingConfig(directory), input.agent)
+        const level = resolveEffort({ marker, session, routing })
+        if (level === undefined) return
+
+        const applied = applyEffort(output.options, level, input.model)
+        if (applied === output.options) {
+          if (marker !== undefined) {
+            const warningKey = `${input.sessionID}:${marker}`
+            if (!warnedEffortLevels.has(warningKey)) {
+              warnedEffortLevels.add(warningKey)
+              await warnContentFree(
+                client,
+                `Reasoning effort ${marker} is not available for agent ${input.agent}; ` +
+                  "request left unchanged."
+              )
+            }
+          }
+          return
+        }
+        output.options = applied
+      } catch {
+        await warnContentFree(client, "Could not apply a reasoning-effort level to a request.")
+      }
+    },
   }
 }

package/scripts/codeops_effort.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+"""Record and clear the opt-in reasoning-effort level for a CodeOps session run.
+
+The skills call this helper when a user passes `--auto-effort`. It writes one
+small JSON file inside the session's CodeOps temp directory; the plugin reads
+that file on every request and applies the level. The command fails closed:
+an invalid level or a directory outside the CodeOps temp root exits with
+status 2 and writes nothing.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+#: The only levels a session flag may record.
+EFFORT_LEVELS = ("low", "medium", "high", "max")
+
+#: Name of the state file the plugin reads.
+STATE_FILE_NAME = "reasoning-effort.json"
+
+
+def codeops_tmp_root() -> Path:
+    """Return the CodeOps-owned temp root for the active temp directory.
+
+    The root mirrors the layout `bin/lib/tmp-hygiene.mjs` owns, so the helper
+    and the plugin resolve the same per-session directory.
+
+    Returns:
+        Resolved path of the CodeOps temp root.
+    """
+    return Path(tempfile.gettempdir()).resolve() / "opencode" / "codeops"
+
+
+def resolve_session_dir(raw_dir: str) -> Path | None:
+    """Validate a session directory argument against the CodeOps temp root.
+
+    A directory is accepted only when it exists, resolves strictly inside the
+    CodeOps temp root, and is not the root itself. Symlinks are resolved, so a
+    link that points outside the root is rejected.
+
+    Args:
+        raw_dir: The `--dir` argument as provided by the caller.
+
+    Returns:
+        The resolved session directory, or None when it is not acceptable.
+    """
+    try:
+        resolved = Path(raw_dir).resolve(strict=True)
+    except (OSError, RuntimeError):
+        # RuntimeError covers a symlink loop on Python 3.12, which the
+        # filesystem reports as ELOOP rather than a plain OSError.
+        return None
+    root = codeops_tmp_root()
+    if resolved == root or root not in resolved.parents:
+        return None
+    if not resolved.is_dir():
+        return None
+    return resolved
+
+
+def state_path(session_dir: Path) -> Path:
+    """Return the state-file path inside a validated session directory.
+
+    Args:
+        session_dir: A directory accepted by `resolve_session_dir`.
+
+    Returns:
+        Path of the reasoning-effort state file.
+    """
+    return session_dir / STATE_FILE_NAME
+
+
+def set_level(session_dir: Path, level: str) -> int:
+    """Write the session level atomically and report it.
+
+    The payload is written to a temporary file in the same directory and then
+    moved over the final name with `os.replace`, so a reader never observes a
+    partially written file.
+
+    Args:
+        session_dir: A validated session directory.
+        level: One of `EFFORT_LEVELS`.
+
+    Returns:
+        Process exit code 0.
+    """
+    payload = {
+        "schema": 1,
+        "reasoning": level,
+        "setAt": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+    }
+    path = state_path(session_dir)
+    descriptor, temporary_name = tempfile.mkstemp(
+        prefix=f"{STATE_FILE_NAME}.", suffix=".tmp", dir=session_dir
+    )
+    try:
+        with os.fdopen(descriptor, "w", encoding="utf-8") as handle:
+            json.dump(payload, handle, separators=(",", ":"), sort_keys=True)
+            handle.write("\n")
+        os.replace(temporary_name, path)
+    except OSError:
+        try:
+            os.unlink(temporary_name)
+        except OSError:
+            pass
+        print("Error: could not write the reasoning-effort state file.", file=sys.stderr)
+        return 2
+    print(f"Reasoning effort set: {level} for this session run.")
+    return 0
+
+
+def clear_level(session_dir: Path) -> int:
+    """Remove the session level when present and report the cleanup.
+
+    Args:
+        session_dir: A validated session directory.
+
+    Returns:
+        Process exit code 0.
+    """
+    try:
+        state_path(session_dir).unlink()
+    except FileNotFoundError:
+        pass
+    except OSError:
+        print("Error: could not remove the reasoning-effort state file.", file=sys.stderr)
+        return 2
+    print("Reasoning effort cleared.")
+    return 0
+
+
+def show_status(session_dir: Path) -> int:
+    """Print the stored session level, or the empty-state message.
+
+    Args:
+        session_dir: A validated session directory.
+
+    Returns:
+        Process exit code 0.
+    """
+    level = None
+    try:
+        payload = json.loads(state_path(session_dir).read_text(encoding="utf-8"))
+        if (
+            isinstance(payload, dict)
+            and payload.get("schema") == 1
+            and payload.get("reasoning") in EFFORT_LEVELS
+        ):
+            level = payload["reasoning"]
+    except (OSError, json.JSONDecodeError):
+        level = None
+    if level is None:
+        print("No session reasoning effort set.")
+    else:
+        print(f"Session reasoning effort: {level}")
+    return 0
+
+
+def parse_args() -> argparse.Namespace:
+    """Parse the command-line arguments.
+
+    Returns:
+        The parsed argparse namespace.
+    """
+    parser = argparse.ArgumentParser(description=__doc__)
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    set_parser = sub.add_parser("set", help="record a session reasoning level")
+    set_parser.add_argument("--dir", required=True, help="session temp directory")
+    set_parser.add_argument("--reasoning", required=True, help="level to record")
+
+    clear_parser = sub.add_parser("clear", help="remove the session reasoning level")
+    clear_parser.add_argument("--dir", required=True, help="session temp directory")
+
+    status_parser = sub.add_parser("status", help="print the session reasoning level")
+    status_parser.add_argument("--dir", required=True, help="session temp directory")
+
+    return parser.parse_args()
+
+
+def main() -> int:
+    """Run the requested command.
+
+    Returns:
+        Process exit code: 0 on success, 2 on invalid input.
+    """
+    args = parse_args()
+    session_dir = resolve_session_dir(args.dir)
+    if session_dir is None:
+        print(
+            "Error: --dir must be an existing session directory inside the CodeOps temp root.",
+            file=sys.stderr,
+        )
+        return 2
+    if args.command == "set":
+        if args.reasoning not in EFFORT_LEVELS:
+            print(
+                "Error: --reasoning must be one of: " + ", ".join(EFFORT_LEVELS) + ".",
+                file=sys.stderr,
+            )
+            return 2
+        return set_level(session_dir, args.reasoning)
+    if args.command == "clear":
+        return clear_level(session_dir)
+    return show_status(session_dir)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/fixtures/catalog-executor.golden.md

@@ -57,3 +57,9 @@ original-goal or smallest-design context blocks execution; report it to the pare
   exactly what is missing or ambiguous as a blocker — never guess, and never edit the
   execution plan or roadmap (the parent session owns those and the user conversation).
 - Report per task, 3-4 lines each: what changed, test status, any blocker.
+- **Workspace hygiene (non-negotiable).** Temporary artifacts you create — verify logs, diffs,
+  patches, scratch directories — belong under `$CODEOPS_TMPDIR` when it is set (otherwise the OS
+  temp directory), never inside the repository. Delete everything you created before reporting
+  done. Never delete user files, versioned artifacts, worktrees, or another session's temporary
+  files. If an artifact must outlive the task, name it and say why. Full rules:
+  `_shared/workspace-hygiene.md`.

package/skills/analyze-project/SKILL.md

@@ -27,3 +27,11 @@ description: Analyze the current repository and create or refresh concise CodeOp
 10. When a specialization signal is strong and no specialist covers it, report the candidate with evidence and recommend the `setup-routing` creation flow ([../../_shared/specialist-agents.md](../../_shared/specialist-agents.md)); never write agent files here. Preserve the `<!-- CODEOPS-SPECIALISTS:START -->` / `<!-- CODEOPS-SPECIALISTS:END -->` block byte-for-byte when refreshing the managed section.
 
 Keep `AGENTS.md` small. Operational routing belongs in `codeops/codeops.json` or `opencode.json`, not prose.
+
+---
+
+> **Workspace hygiene (non-negotiable):** put every temporary artifact this run creates in
+> `$CODEOPS_TMPDIR` (fallback: the OS temp directory), never in the repository, and delete them
+> all before reporting completion. Never delete user files, versioned artifacts, worktrees, or
+> another session's temporary files. Full rules:
+> [_shared/workspace-hygiene.md](../../_shared/workspace-hygiene.md).

package/skills/clean-comments/SKILL.md

@@ -20,3 +20,11 @@ This is a comment-only workflow. Never alter executable tokens, declarations, ty
 7. Review the diff to prove only comments changed. Run the repository's normal formatter and verification command.
 
 Documentation explains the shipped system, not the temporary process that produced it.
+
+---
+
+> **Workspace hygiene (non-negotiable):** put every temporary artifact this run creates in
+> `$CODEOPS_TMPDIR` (fallback: the OS temp directory), never in the repository, and delete them
+> all before reporting completion. Never delete user files, versioned artifacts, worktrees, or
+> another session's temporary files. Full rules:
+> [_shared/workspace-hygiene.md](../../_shared/workspace-hygiene.md).

package/skills/exec-plan/SKILL.md

@@ -36,6 +36,18 @@ do not report or implement optional additions raised during execution or review.
 Exploration may create `SE-*` proposals, but only the user may choose `Keep` and authorize a plan
 update.
 
+## Auto-effort option
+
+If `$ARGUMENTS` contains exactly one exact standalone `--auto-effort` or `--auto-effort=<level>`
+token before the first `--` sentinel, remove it before resolving targets, paths, or modes; zero
+occurrences means each phase's `Reasoning:` level is printed as a suggestion only, more than one
+or an invalid level is an argument error; announce
+`Auto-effort active — reasoning <level> applied for this run`; then read and apply
+[../../_shared/reasoning-effort.md](../../_shared/reasoning-effort.md) §Auto-effort option. A bare
+flag follows each phase's suggestion; `--auto-effort=<level>` forces that level for the whole run,
+including every dispatch marker composed during it. The run clears the level before its final
+summary.
+
 Execute the implementation plan at `plans/$ARGUMENTS/99-execution-plan.md`. The first
 argument is the feature name; an optional flag selects the commit mode.
 
@@ -267,3 +279,12 @@ Brief rules for verification failure, plan deviation, and mid-task interruption
   files and use only facts you can read — do not invent settings.
 - Commit using the `git-commit` skill (commit only) or the `git-commit` skill in push mode (commit + push), or a normal git commit.
 - Related skills: make-plan (creation), upgrade-plan (outdated plans), preflight, roadmap, techdocs.
+- Cleanup is part of session wrap-up: delete the run's verify logs and scratch per
+  [../../_shared/workspace-hygiene.md](../../_shared/workspace-hygiene.md) and report
+  `Cleanup: done` in the session summary.
+
+> **Workspace hygiene (non-negotiable):** put every temporary artifact this run creates in
+> `$CODEOPS_TMPDIR` (fallback: the OS temp directory), never in the repository, and delete them
+> all before reporting completion. Never delete user files, versioned artifacts, worktrees, or
+> another session's temporary files. Full rules:
+> [_shared/workspace-hygiene.md](../../_shared/workspace-hygiene.md).

package/skills/exec-plan/execution-protocol.md

@@ -70,6 +70,10 @@ scope baseline; missing mode context fails closed to strict scope.
 When opt-in outcome metrics are enabled, record only a content-free execution-stage event through
 `codeops_outcomes.py`; metrics never gate execution.
 
+When the phase header carries `> **Reasoning**: <level> — <reason>`, record it as the phase's
+advisory level for dispatch markers, inline reporting, and applied-level reporting. It is a
+suggestion: no gate reads it, and its absence means "inherit".
+
 **Spec-author dispatch (profile-gated).** Tasks marked `[spec-author]` dispatch the
 spec-test-author agent — packet per `_shared/quality-profile.md` — BEFORE any implementation
 task of that phase, and the red phase is confirmed from its report. A spec test that cannot be
@@ -225,7 +229,8 @@ red-phase, green-phase, session wrap-up — executes with output captured to a t
 <verify command> > "$VERIFY_LOG" 2>&1
 ```
 
-(`$VERIFY_LOG` = a file in the session temp/scratchpad dir, e.g. `verify-<task-id>.log`.)
+(`$VERIFY_LOG` = a file under `$CODEOPS_TMPDIR` — or the OS temp directory when it is unset —
+e.g. `verify-<task-id>.log`.)
 
 - **PASS** → surface ONE line: `VERIFY PASS (task N.N.N)`, plus the test count if it is
   extractable from the log tail at no extra cost.
@@ -234,10 +239,11 @@ red-phase, green-phase, session wrap-up — executes with output captured to a t
 - **Red-phase runs** (spec tests expected to fail) → surface only the failing spec-test
   names/count confirming the red state — never the full dump.
 
-The full log always remains on disk for the session. If the log location is unwritable, fall
-back to running verify plainly ONCE and note the fallback in the session summary. This rule is
-about CONTEXT, not rigor: the verify command itself, its scope, and pass/fail gating are
-unchanged — and the temp log is read-only evidence, never executed.
+The full log remains on disk until the session wrap-up cleanup deletes it (see
+`_shared/workspace-hygiene.md`); nothing in the transcript depends on it afterward. If the log
+location is unwritable, fall back to running verify plainly ONCE and note the fallback in the
+session summary. This rule is about CONTEXT, not rigor: the verify command itself, its scope, and
+pass/fail gating are unchanged — and the temp log is read-only evidence, never executed.
 
 ### Zero-Ambiguity During Execution
 
@@ -298,12 +304,46 @@ receives nothing else and must not need anything else:
 - the scope mode (`strict` or `explore`) and confirmed product scope baseline; missing or invalid
   scope context fails closed to strict mode. Missing or invalid original-goal or smallest-design
   context blocks dispatch;
-- the target file paths and the project's verify command.
+- the target file paths and the project's verify command;
+- the phase's reasoning marker line (`[codeops-effort: <level>]`), resolved from the run's forced
+  `--auto-effort=<level>` level, else the phase's `Reasoning:` suggestion; omitted when neither
+  exists.
 
 Excerpting owned content into a packet is the intended retrieval mechanism, not restatement. The
 quoted AR/ST/spec content is context for the executor's *understanding* — it must not surface as a
 citation in shipped code (the executor carries the same doc-standard ban and self-check).
 
+**Reasoning marker.** Every dispatched unit — executor, reviewer, auditor, spec-test author,
+specialist, or scout — receives one standalone marker line in its packet:
+
+```text
+[codeops-effort: medium]
+```
+
+Place it immediately after the `[codeops-dispatch …]` header for quality agents, or as the first
+line for packets without a header. When neither the forced run level nor the phase suggestion
+exists, add no marker: routing policy still applies, otherwise the child inherits the parent
+variant. The marker is packet context; it never appears in shipped code comments. The
+complexity-gate design challenger is excluded because its independence contract forbids extra
+packet shaping.
+
+**Applied-level reporting.** For every dispatch, report the level and its source in the dispatch
+commentary, for example `Dispatch: executor — reasoning: medium (phase suggestion)`,
+`— reasoning: high (routing default)`, or `— inherited`. Reporting is observational; it never
+gates a dispatch.
+
+**Inline phases.** When a phase runs inline (the default):
+
+1. Print `Suggested reasoning: <level> — <reason>` before the phase's first task when the phase
+   header carries the line.
+2. Without `--auto-effort`, change nothing else — the session keeps its own variant.
+3. With `--auto-effort`, set the session level for the phase through
+   `python3 "${CODEOPS_PLUGIN_ROOT}/scripts/codeops_effort.py" set --dir "$CODEOPS_TMPDIR" --reasoning <level>`
+   and update it when the next phase's suggestion differs; with `--auto-effort=<level>`, set that
+   level once and keep it for the whole run. A phase without a `Reasoning:` line leaves the
+   session level unchanged.
+4. When `$CODEOPS_TMPDIR` is empty or the helper fails, print an advise-only note and continue.
+
 **Division of labor.** The PARENT — never the executor — updates `99-execution-plan.md`
 (two-stage marks), the Progress header, and the roadmap. The executor implements task-by-task,
 runs verify per the Verify-output capture rule, and reports per task. Mark `[~]` as the executor
@@ -402,7 +442,12 @@ otherwise still `[~]` — with the progress counter and Last Updated stamp curre
 2. **🚨 First: update `99-execution-plan.md`** with ALL completed tasks (before anything else).
 3. Run the verify command (output captured per the Verify-output capture rule).
 4. Handle the commit per the active commit mode (see [commit-modes.md](commit-modes.md)).
-5. Report the session summary (must include `Execution Plan Updated: ✅`).
+5. If this run set a session level through `--auto-effort`, clear it before the summary:
+   `python3 "${CODEOPS_PLUGIN_ROOT}/scripts/codeops_effort.py" clear --dir "$CODEOPS_TMPDIR"`.
+6. Report the session summary (must include `Execution Plan Updated: ✅`).
+7. **Cleanup:** delete every temporary artifact this session created — verify logs under
+   `$CODEOPS_TMPDIR`, scratch directories, temporary diffs — per
+   `_shared/workspace-hygiene.md`, and report `Cleanup: done` or name what was kept and why.
 
 ### Session Summary Template
 

package/skills/git-commit/SKILL.md

@@ -14,13 +14,14 @@ A request to commit authorizes a local commit only. Push only when the user expl
 1. Resolve the repository root and inspect `git status --short`, staged/unstaged diffs, and recent commit style.
 2. If clean, report `nothing to commit` and stop.
 3. Inspect every untracked file. Stop and ask before staging likely secrets, credentials, build output, large binaries, or unrelated scratch files.
-4. Resolve the authoritative verification command from `AGENTS.md`, CodeOps plan Verify lines, or project manifests. Run it with output captured to a temporary log. On failure, report the failure tail and do not stage or commit.
+4. Resolve the authoritative verification command from `AGENTS.md`, CodeOps plan Verify lines, or project manifests. Run it with output captured to a log under `$CODEOPS_TMPDIR` (fallback: the OS temp directory), never in the repository. On failure, report the failure tail and do not stage or commit.
 5. Stage deliberately by explicit paths or coherent groups. Avoid `git add .` when the working directory may be a monorepo subtree or unrelated changes exist.
 6. Review `git diff --cached --check`, the staged stat, and the staged diff. Ensure the commit contains one coherent purpose and preserves unrelated user changes.
-7. Write a Conventional Commit message to a temporary file and commit with `git commit -F`. Never use an inline multiline message.
+7. Write a Conventional Commit message to a temporary file under `$CODEOPS_TMPDIR` (fallback: the OS temp directory) and commit with `git commit -F`. Never use an inline multiline message.
 8. If a commit hook modifies files, inspect and restage only relevant changes, then retry once. Never use `--no-verify` automatically.
 9. For push mode, fetch/rebase only when appropriate for the branch policy. Stop on conflicts; never resolve ambiguous conflicts automatically. Push normally, never with force.
 10. Report the resulting commit, verification, and push state.
+11. Delete the temporary verification log and commit-message file, then report `Cleanup: done` or name what was kept and why.
 
 ## Message shape
 
@@ -33,3 +34,11 @@ type(scope): imperative summary
 ```
 
 Use `feat`, `fix`, `refactor`, `test`, `docs`, or `chore` unless repository guidance defines another convention.
+
+---
+
+> **Workspace hygiene (non-negotiable):** put every temporary artifact this run creates in
+> `$CODEOPS_TMPDIR` (fallback: the OS temp directory), never in the repository, and delete them
+> all before reporting completion. Never delete user files, versioned artifacts, worktrees, or
+> another session's temporary files. Full rules:
+> [_shared/workspace-hygiene.md](../../_shared/workspace-hygiene.md).

package/skills/github-issues/SKILL.md

@@ -36,3 +36,11 @@ For each issue:
 5. Continue past nonexistent individual issues but record every outcome.
 
 Return a per-issue summary. Never create, edit, label, close, reopen, or comment unless the user's request explicitly authorizes that mutation.
+
+---
+
+> **Workspace hygiene (non-negotiable):** put every temporary artifact this run creates in
+> `$CODEOPS_TMPDIR` (fallback: the OS temp directory), never in the repository, and delete them
+> all before reporting completion. Never delete user files, versioned artifacts, worktrees, or
+> another session's temporary files. Full rules:
+> [_shared/workspace-hygiene.md](../../_shared/workspace-hygiene.md).

package/skills/grill-me/SKILL.md

@@ -21,6 +21,16 @@ implementation work begins.
 
 > **CodeOps Artifact Schema**: 1
 
+## Auto-effort option
+
+If `$ARGUMENTS` contains exactly one exact standalone `--auto-effort` or `--auto-effort=<level>`
+token before the first `--` sentinel, remove it before resolving targets, paths, or modes; zero
+occurrences means this skill's recommended level (`high`) is printed as a suggestion only, more
+than one or an invalid level is an argument error; announce
+`Auto-effort active — reasoning <level> applied for this run`; then read and apply
+[../../_shared/reasoning-effort.md](../../_shared/reasoning-effort.md) §Auto-effort option. The
+run clears the level before its final summary.
+
 ## Core Directive
 
 > **Interview the user relentlessly about every aspect of the topic until you reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one.**
@@ -340,3 +350,11 @@ grill-me → identify design tree → walk each branch → resolve decisions →
 
 **Output:** A shared understanding summary with all decisions, assumptions,
 constraints, and deferrals — ready to feed into any downstream skill.
+
+---
+
+> **Workspace hygiene (non-negotiable):** put every temporary artifact this run creates in
+> `$CODEOPS_TMPDIR` (fallback: the OS temp directory), never in the repository, and delete them
+> all before reporting completion. Never delete user files, versioned artifacts, worktrees, or
+> another session's temporary files. Full rules:
+> [_shared/workspace-hygiene.md](../../_shared/workspace-hygiene.md).