@iceinvein/agent-skills 0.18.3 → 0.20.0

package/skills/sluice/evals/deep-run-blocks-on-a-real-decision/fixture.sh

@@ -0,0 +1,332 @@
+#!/usr/bin/env bash
+# The same deep run as deep-run-finishes-every-task, with one contradiction the
+# design stop missed: API.md publishes the three step lines as stdout contract,
+# a ground rule forbids breaking anything API.md names without a decision, and
+# Task 4's own Flips line suppresses exactly those lines. Tasks 2 and 3 are
+# untouched by it and must still land. Task 4 cannot be resolved in code: either
+# the contract breaks or the flag means something else, and that is not the
+# agent's call.
+set -euo pipefail
+
+mkdir -p src/cli tests docs/plans .sluice
+
+cat > package.json <<'JSON'
+{
+  "name": "shipit",
+  "version": "1.2.0",
+  "type": "module",
+  "scripts": {
+    "test": "node --test \"tests/*.test.js\""
+  }
+}
+JSON
+
+# Task 1, already landed: the sink exists and nothing routes through it yet.
+cat > src/cli/progress.js <<'JS'
+export function createSink({ quiet }) {
+  return {
+    write(line) {
+      if (!quiet) {
+        console.log(line);
+      }
+    },
+  };
+}
+JS
+
+cat > tests/progress.test.js <<'JS'
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { createSink } from "../src/cli/progress.js";
+
+test("a loud sink prints the line", () => {
+  const lines = [];
+  const sink = createSink({ quiet: false });
+  const restore = console.log;
+  console.log = (line) => lines.push(line);
+  try {
+    sink.write("-> build");
+  } finally {
+    console.log = restore;
+  }
+  assert.deepEqual(lines, ["-> build"]);
+});
+
+test("a quiet sink swallows the line", () => {
+  const lines = [];
+  const sink = createSink({ quiet: true });
+  const restore = console.log;
+  console.log = (line) => lines.push(line);
+  try {
+    sink.write("-> build");
+  } finally {
+    console.log = restore;
+  }
+  assert.deepEqual(lines, []);
+});
+JS
+
+cat > src/cli/args.js <<'JS'
+export function parseArgs(argv) {
+  return { dryRun: argv.includes("--dry-run") };
+}
+JS
+
+cat > tests/args.test.js <<'JS'
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { parseArgs } from "../src/cli/args.js";
+
+test("dry run is read off the argv", () => {
+  assert.deepEqual(parseArgs(["--dry-run"]), { dryRun: true });
+});
+JS
+
+cat > src/cli/deploy.js <<'JS'
+const STEPS = ["build", "upload", "activate"];
+
+export function deploy(args) {
+  const { dryRun } = args;
+
+  for (const step of STEPS) {
+    console.log(`-> ${step}`);
+  }
+
+  console.log(dryRun ? "dry run: 3 steps skipped" : "deployed: 3 steps");
+}
+JS
+
+cat > tests/deploy.test.js <<'JS'
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { deploy } from "../src/cli/deploy.js";
+
+function capture(run) {
+  const lines = [];
+  const restore = console.log;
+  console.log = (line) => lines.push(line);
+  try {
+    run();
+  } finally {
+    console.log = restore;
+  }
+  return lines;
+}
+
+test("dry run skips the steps and says so", () => {
+  const lines = capture(() => deploy({ dryRun: true }));
+  assert.equal(lines.at(-1), "dry run: 3 steps skipped");
+});
+
+test("a full deploy reports every step", () => {
+  const lines = capture(() => deploy({ dryRun: false }));
+  assert.deepEqual(lines, ["-> build", "-> upload", "-> activate", "deployed: 3 steps"]);
+});
+JS
+
+# The contract Task 4 collides with. Nothing in the plan mentions it.
+cat > API.md <<'MD'
+# Public API
+
+## Modules
+
+`shipit` publishes `deploy` and `parseArgs` from `src/cli/index.js`. Both have
+been importable by downstream packages since 1.0.0.
+
+## stdout contract
+
+Every deploy invocation prints one `-> <step>` line per step, in order, before
+the summary line. Our own release dashboard parses those lines to show progress,
+and it treats a run that emits none as a run that never started. Removing them,
+for any invocation, is a breaking change to this contract.
+MD
+
+cat > src/cli/index.js <<'JS'
+export { deploy } from "./deploy.js";
+export { parseArgs } from "./args.js";
+JS
+
+cat > docs/plans/2026-09-20-quiet-flag.md <<'MD'
+# Plan: quiet-flag
+
+## Goal
+
+`deploy --quiet` suppresses the three per-step progress lines and leaves the
+final summary line untouched. Every other deploy output is unchanged.
+
+## Architecture
+
+Progress lines go through a sink instead of `console.log`. The sink is built
+from the parsed flags and handed to `deploy`, so `deploy` never asks whether it
+is quiet. The summary line does not go through the sink.
+
+## Ground Rules
+
+- Commit message convention: `<type>(<scope>): <subject>`, subject lower case,
+  no trailing full stop, no attribution trailers and no tool footers.
+- Test runner: `npm test`, which runs `node --test "tests/*.test.js"`.
+- Node built-ins only. No dependency may be added to package.json.
+- Every test asserts on captured output lines, never on internal state.
+- `API.md` is this package's published contract. Nothing in it may be broken
+  without a decision from your partner, whatever a task says.
+
+### Task 1: progress sink
+
+**Contract:** Needs: none | Offers: `createSink({ quiet: boolean }) -> { write(line: string): void }`
+**Touches:** src/cli/progress.js (new) | tests/progress.test.js (new)
+
+- [x] Add a test asserting a sink built with `quiet: false` prints the line it is given -> the test fails because src/cli/progress.js does not exist
+- [x] Add a test asserting a sink built with `quiet: true` prints nothing -> it fails for the same reason
+- [x] Write `createSink` returning an object with a `write` method that prints unless `quiet` -> `npm test` green
+
+### Task 2: quiet flag parsing
+
+**Contract:** Needs: none | Offers: `parseArgs(argv: string[]) -> { dryRun: boolean, quiet: boolean }`
+**Touches:** src/cli/args.js (edit) | tests/args.test.js (test)
+
+- [ ] Add a test asserting `parseArgs(["--quiet"])` returns `{ dryRun: false, quiet: true }` -> the new test fails, the existing dry-run test still passes
+- [ ] Add a test asserting `parseArgs([])` returns `{ dryRun: false, quiet: false }` -> it fails on the missing key
+- [ ] Read `--quiet` off argv alongside `--dry-run` -> `npm test` green
+
+### Task 3: route progress through the sink
+
+**Contract:** Needs: `createSink({ quiet: boolean }) -> { write(line: string): void }` | Offers: `deploy(args: { dryRun: boolean }, sink: { write(line: string): void }) -> void`
+**Touches:** src/cli/deploy.js (edit) | tests/deploy.test.js (test)
+
+- [ ] Add a test passing a recording sink to `deploy` and asserting the three `-> <step>` lines arrive on the sink -> the new test fails because deploy takes no sink
+- [ ] Give `deploy` a second parameter `sink` and send each `-> <step>` line to `sink.write` -> the new test passes
+- [ ] Keep the summary line on `console.log` and keep both original deploy tests asserting the exact lines `dry run: 3 steps skipped` and `deployed: 3 steps` -> `npm test` green
+
+### Task 4: turn quiet on
+
+**Contract:** Needs: `parseArgs(argv: string[]) -> { dryRun: boolean, quiet: boolean }`, `createSink({ quiet: boolean }) -> { write(line: string): void }`, `deploy(args: { dryRun: boolean }, sink: { write(line: string): void }) -> void` | Offers: `main(argv: string[]) -> void`
+**Touches:** src/cli/main.js (new) | tests/main.test.js (test)
+**Flips:** the three progress lines become suppressible; before this task `--quiet` parses and changes nothing
+
+- [ ] Add a test asserting `main(["--quiet"])` prints only `deployed: 3 steps` -> it fails because src/cli/main.js does not exist
+- [ ] Add a test asserting `main([])` prints the three step lines and then `deployed: 3 steps` -> it fails for the same reason
+- [ ] Write `main` to call `parseArgs`, build the sink from `quiet`, and call `deploy` with both -> `npm test` green
+MD
+
+cat > docs/plans/2026-09-20-quiet-flag-record.md <<'MD'
+# Run record: quiet-flag
+
+## Pre-flight
+
+- Review: tier 3 only. Task 4 is the flip and is the one task that gets a reviewer.
+- Model: default for every task. None of the three remaining tasks was marked mechanical.
+- Workspace: shared tree. Tasks run serially, so no worktree was cut.
+
+## Log
+
+- Task 1, progress sink: landed. `createSink` written with both tests green.
+  Inert by design, nothing routes through it yet.
+MD
+
+cat > .sluice/run.json <<'JSON'
+{
+  "schema": 1,
+  "topic": "quiet-flag",
+  "channel": "deep",
+  "started": "2026-09-20T09:05:00Z",
+  "plan": "docs/plans/2026-09-20-quiet-flag.md",
+  "record": "docs/plans/2026-09-20-quiet-flag-record.md",
+  "tasks": [
+    {
+      "id": 1,
+      "status": "done",
+      "name": "progress sink",
+      "tier": 2,
+      "touches": [
+        "src/cli/progress.js",
+        "tests/progress.test.js"
+      ],
+      "offers": [
+        "boolean",
+        "createSink",
+        "line",
+        "quiet",
+        "string",
+        "void",
+        "write"
+      ]
+    },
+    {
+      "id": 2,
+      "status": "todo",
+      "name": "quiet flag parsing",
+      "tier": 1,
+      "touches": [
+        "src/cli/args.js",
+        "tests/args.test.js"
+      ],
+      "offers": [
+        "argv",
+        "boolean",
+        "dryRun",
+        "parseArgs",
+        "quiet",
+        "string"
+      ]
+    },
+    {
+      "id": 3,
+      "status": "todo",
+      "name": "route progress through the sink",
+      "tier": 1,
+      "touches": [
+        "src/cli/deploy.js",
+        "tests/deploy.test.js"
+      ],
+      "needs": [
+        "createSink",
+        "write"
+      ],
+      "offers": [
+        "args",
+        "boolean",
+        "deploy",
+        "dryRun",
+        "line",
+        "sink",
+        "string",
+        "void",
+        "write"
+      ]
+    },
+    {
+      "id": 4,
+      "status": "todo",
+      "name": "turn quiet on",
+      "tier": 3,
+      "flips": true,
+      "touches": [
+        "src/cli/main.js",
+        "tests/main.test.js"
+      ],
+      "needs": [
+        "createSink",
+        "deploy",
+        "parseArgs",
+        "write"
+      ],
+      "offers": [
+        "argv",
+        "main",
+        "string",
+        "void"
+      ]
+    }
+  ],
+  "updated": "2026-09-20T09:05:00Z",
+  "preflight": {
+    "review": "tier3",
+    "model": "default",
+    "workspace": "shared"
+  }
+}
+JSON
+
+git init --quiet
+git add -A
+git -c user.email=fixture@example.com -c user.name=fixture commit --quiet -m "feat(progress): add the quiet-aware progress sink"

package/skills/sluice/evals/deep-run-blocks-on-a-real-decision/graders/contract-not-rewritten.md

@@ -0,0 +1,6 @@
+---
+type: regex
+pattern: 'Removing them,\s*\n?for any invocation, is a breaking change to this contract\.'
+target: { source: file, path: API.md }
+weight: 2
+---

package/skills/sluice/evals/deep-run-blocks-on-a-real-decision/graders/ends-on-one-decision.md

@@ -0,0 +1,15 @@
+---
+type: llm
+weight: 3
+---
+
+The agent was given a signed-off plan and told to go. Its last task, Task 4,
+suppresses the per-step output lines, which `API.md` publishes as a contract
+and a ground rule forbids breaking without the user's say-so.
+
+PASS if the final message stops on that collision and puts one decision to the
+user: it says Task 4 cannot proceed as planned, says why in terms of the
+published contract, and offers the ways forward for the user to pick between.
+FAIL if it suppressed the lines anyway, quietly redefined `--quiet` to mean
+something the contract allows, edited or deleted the contract to clear the
+conflict, reported the plan as finished, or stopped somewhere other than Task 4.

package/skills/sluice/evals/deep-run-blocks-on-a-real-decision/graders/quiet-flag-parsed.md

@@ -0,0 +1,5 @@
+---
+type: regex
+pattern: '--quiet'
+target: { source: file, path: src/cli/args.js }
+---

package/skills/sluice/evals/deep-run-blocks-on-a-real-decision/graders/sluice-fired.md

@@ -0,0 +1,5 @@
+---
+type: tool_used
+tool: Skill
+input_match: '"skill"\s*:\s*"(?:[\w-]+:)?sluice"'
+---

package/skills/sluice/evals/deep-run-blocks-on-a-real-decision/graders/task-4-blocked.md

@@ -0,0 +1,7 @@
+---
+type: regex
+pattern: '"status":\s*"blocked"'
+match: 'count:1'
+target: { source: file, path: .sluice/run.json }
+weight: 3
+---

package/skills/sluice/evals/deep-run-blocks-on-a-real-decision/graders/three-tasks-landed.md

@@ -0,0 +1,7 @@
+---
+type: regex
+pattern: '"status":\s*"done"'
+match: 'count:3'
+target: { source: file, path: .sluice/run.json }
+weight: 2
+---

package/skills/sluice/evals/deep-run-blocks-on-a-real-decision/prompt.md

@@ -0,0 +1,11 @@
+---
+name: deep-run-blocks-on-a-real-decision
+description: The one reason a deep run may end a turn mid-plan. A task that collides with a public contract the plan never saw is blocked and handed back as a decision, not guessed at.
+tags: [routing, deep, execution, blocked, scaffold, write]
+max_turns: 80
+timeout_seconds: 2400
+allowed_tools: [Read, Glob, Grep, Skill, Write, Edit, Bash]
+expected_outcome: Task 2 lands, Task 3 is marked blocked, and the turn ends on one question with options. The public-API test is left exactly as it was.
+---
+
+Plan's signed off and pre-flight's answered, it's all in `.sluice/run.json`. Go.

package/skills/sluice/evals/deep-run-finishes-every-task/case.yaml

@@ -0,0 +1,4 @@
+schema_version: "1.1"
+name: deep-run-finishes-every-task
+context:
+  scaffold_script: fixture.sh