pi-glossary generic shared workflow glossary

pi-glossary-generic-workflows.json

[
  {
    "term": "pbcopy",
    "aliases": [
      "pbcopied",
      "pbcopying"
    ],
    "definition": "Used as a verb: send the relevant part of the work to pbcopy (the macOS CLI tool that copies stdin to the clipboard). The 'relevant part' is the final product, stripped of meta-commentary. Examples: during a proofread, pipe only the rewritten message (no notes about the changes) to pbcopy; when iterating on a prompt, pipe only the latest version of the prompt itself (no commentary about it). If unsure what counts as the final product, ask before copying.",
    "source": "https://gist.github.com/ruliana/f7e59fe5622560c498c3bd4e6d36a353"
  },
  {
    "term": "clarask",
    "aliases": [
      "clarasked",
      "clarasking"
    ],
    "definition": "Ask clarifying questions conversationally before starting the task; use an interaction tool only when one is available. If the request is already unambiguous, skip the questions and continue.",
    "source": "https://gist.github.com/ruliana/f7e59fe5622560c498c3bd4e6d36a353"
  },
  {
    "term": "explore-plan",
    "aliases": [
      "explore and plan",
      "e&p",
      "EP"
    ],
    "definition": "A workflow pattern: [[orchestrate]] explore and plan only; do not mutate the project, run migrations, or create commits. Explore gathers context and evidence-backed findings. Plan produces a step-by-step plan, risks, validation strategy, and open questions. Project mutations are distinct from Logseq persistence: [[lapture]] the plan only when writes are permitted. For a read-only/no-modify request, return the plan without persistence. Ask the user only for decisions that cannot be resolved from code, docs, or history.",
    "source": "https://gist.github.com/ruliana/f7e59fe5622560c498c3bd4e6d36a353"
  },
  {
    "term": "explore-plan-execute-review",
    "aliases": [
      "EPER"
    ],
    "definition": "A workflow pattern: [[orchestrate]] a task through explore → plan. Explore gathers evidence-backed context. Plan produces an implementation plan; a pragmatic plan review loops with the planner until no blocking findings remain or two iterations fail to converge. [[lapture]] the plan only when writes are permitted. Then use [[execute-review-loop]] for the accepted implementation. If constraints forbid execution, stop after returning the plan. Preserve user constraints, including read-only/no-modify/no-commit requests, in every subagent prompt. If reviewers conflict, requirements are ambiguous, constraints would be violated, or the plan-review loop does not converge, stop and ask the user.",
    "source": "https://gist.github.com/ruliana/f7e59fe5622560c498c3bd4e6d36a353"
  },
  {
    "term": "execute-review-loop",
    "aliases": [
      "execute-review"
    ],
    "definition": "Initial guard: when user constraints prohibit implementation or modifications, do not implement and report that the loop cannot run. A workflow pattern: implement the requested change, then [[orchestrate]] reviewer [[subagent]]s selected by role and task fit from the current `subagent-cli --list` inventory. Select a pragmatic artifact reviewer for every task; for code changes, add architecture and code-smell reviewers when available. Address only actionable findings with severity or concrete failure modes; ignore style-only feedback unless it affects maintainability. Re-run the same reviewers after fixes. Stop when every reviewer reports no blocking findings. If reviewers conflict or two loops do not converge, stop and summarize the disagreement for the user.",
    "source": "https://gist.github.com/ruliana/f7e59fe5622560c498c3bd4e6d36a353"
  },
  {
    "term": "gubmit",
    "definition": "Commit the current execution (new commit), then push via Graphite `gt submit`. Default flag: `--stack --update-only` (only updates existing PRs, will not create new ones — the safe default for a normal save-and-push). Switch to `--no-interactive --branch <branch>` (or drop `--update-only`) when the context is creating a draft PR for a brand-new branch — e.g. when the user just asked to create a new branch on top of the stack and gubmit it. If unsure which mode applies, prefer the default and ask.",
    "source": "https://gist.github.com/ruliana/f7e59fe5622560c498c3bd4e6d36a353"
  },
  {
    "term": "grill",
    "aliases": [
      "grilled",
      "grilling"
    ],
    "definition": "Interview the user until the next action is unambiguous. Investigate questions answerable from the codebase, web, local files, or history before asking. Then ask one consequential unresolved question at a time, with a recommended answer, resolving dependencies before moving to another branch. Stop when remaining uncertainty no longer changes the next action. Ask conversationally; use an interaction tool only when one is available.",
    "source": "https://github.com/mattpocock/skills/blob/main/skills/productivity/grill-me/SKILL.md"
  },
  {
    "term": "rapid fire",
    "aliases": [
      "rapid-fire",
      "rapidfire"
    ],
    "definition": "The user is aligning understanding through a quick back-and-forth: they will ask short questions one after another. Answer each one with a short, focused, grounded reply. No preamble, no hedging, no exploring tangents — just the direct answer to the specific question asked. Wait for the next question instead of expanding scope.",
    "source": "https://gist.github.com/ruliana/f7e59fe5622560c498c3bd4e6d36a353"
  },
  {
    "term": "worchestrate",
    "aliases": [
      "worchestrates",
      "worchestrating",
      "worchestrated",
      "worchestrator"
    ],
    "definition": "A script-first evolution of [[orchestrate]]. The main agent creates a shell script that owns the orchestration: spawning [[subagent]]s, collecting artifact paths, asking evaluator subagents to return machine-readable labels/scores/decisions, parsing those outputs, and using them in shell conditionals or loops to choose the next step. The script parallelizes independent subagent work as much as possible, joins background runs with `wait` or `subagent-cli --wait <artifact>...` instead of sleep-polling, and chains dependent steps through artifact paths. The main agent designs this control flow by identifying task dependencies and coding the script so workflow state, branching logic, fan-out/fan-in coordination, and repeatable control flow live outside the main context.",
    "source": "https://gist.github.com/ruliana/f7e59fe5622560c498c3bd4e6d36a353"
  },
  {
    "term": "orchestrate",
    "aliases": [
      "orchestrated",
      "orchestrating",
      "orchestrator",
      "team of agents",
      "team of subagents",
      "team of sub-agents",
      "orchestrates"
    ],
    "definition": "Spawn one or more [[subagent]]s to execute the request — never do delegated work directly. The main agent acts as orchestrator only: decompose the request into focused tasks, list available user agents at runtime with `subagent-cli --list`, select agents by their descriptions and task fit, run `subagent-cli --artifact auto <agent> \"<task>\"` for each task, then read the resulting artifacts and synthesize the results, citing the artifact paths used in the synthesis. Spawn agents in parallel when tasks are independent or parallelism materially reduces elapsed time by backgrounding each command and `wait`ing in the same shell invocation, or `subagent-cli --wait <artifact>...` when the runs are detached — never by sleeping and re-checking; chain dependent work by passing prior artifact paths into the next task. This shared contract owns traceability for delegated work.",
    "source": "https://gist.github.com/ruliana/f7e59fe5622560c498c3bd4e6d36a353"
  },
  {
    "term": "subagent",
    "aliases": [
      "subagents",
      "sub-agent",
      "sub-agents"
    ],
    "definition": "A non-interactive Pi process spawned to execute one focused task with isolated context. List available user agents with `subagent-cli --list`; use `subagent-cli --scope both --list` only when trusted repo-local `.pi/agents` should be eligible. Use [[subagent-cli]] instead of manually parsing frontmatter or composing `pi -p` arguments: `subagent-cli --artifact auto <agent> \"<task>\"`. The CLI selects the agent definition, applies its `model`/`tools`/`skills` frontmatter, appends the prompt body, runs `pi -p --no-session`, and in artifact mode writes `/tmp/subagent-<main-session-uuid>-<agent>-<slug>.md`. Never poll with `sleep`. Run parallel subagents inside a single shell invocation and join them with `wait`; for runs detached across invocations (`nohup ... &`), give each an explicit `--artifact <path>` and block with `subagent-cli --wait <path>...`. Reference artifact paths in subsequent prompts instead of pasting full outputs. Keep each subagent task focused and include any user constraints explicitly.",
    "source": "https://gist.github.com/ruliana/f7e59fe5622560c498c3bd4e6d36a353"
  },
  {
    "term": "dapy",
    "definition": "Do not change anything; just answer what the user asked.",
    "source": "https://gist.github.com/ruliana/f7e59fe5622560c498c3bd4e6d36a353"
  }
]