[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M758J97SSNRCMWY011EP4792":3,"skill-same:01M758J97SSNRCMWY011EP4792":75},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":46,"commitSha":47,"skillDirectory":48,"forksCount":49,"repositoryHtmlUrl":50,"repositoryHomepageUrl":51,"ownerHtmlUrl":52,"ownerBlogUrl":6,"ownerDescription":53,"updatedAt":54,"install":55,"resources":68},"01M758J97SSNRCMWY011EP4792","task-queue-workflow",null,"Use when claiming task-db slices under task model v3.","lukemcqueen\u002Fsteadfaste-fleet","lukemcqueen","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F405240?v=4","01M757MHPAGRXTJAT46SKZP98R","Luke McQueen","01M757MHPZ573KP8DT9GB8SBQ7",4,"MIT","https:\u002F\u002Fgithub.com\u002Flukemcqueen\u002Fsteadfaste-fleet\u002Fblob\u002Fmain\u002Fskills\u002Fdevops\u002Ftask-queue-workflow\u002FSKILL.md",[],[],"2026-11-12 13:55:43",false,"---\nname: task-queue-workflow\nversion: 1.0.0\ncategory: devops\ndescription: \"Use when claiming task-db slices under task model v3.\"\nauthor: Steadfaste Fleet\nplatforms: [linux, macos]\nmetadata:\n  hermes:\n    tags: [tasks, task-model-v3, orchestrator, worker, claim, verify, review, board]\n    related_skills: [orch-bus-worker, postgres-schema-design, loop-governance, change-test-loop]\n---\n\n# Task Queue Workflow — Task Model v3 (orchestrator-intelligence \u002F worker-execution)\n\n## When to Use\n\n- Any agent claiming or executing a slice from the task queue\n- Orchestrators decomposing stories, dispatching, or verifying completions\n- Reading the task board or daily digest\n- Design: `docs\u002Fdesign\u002Ftask-model-v3.md`; schema: `ops\u002Fservices\u002Ftasks\u002Fschema\u002F` (a version-gated runner; the highest `vNNN__` file present wins — see the migration pitfall below)\n\n## The Model\n\nTwo tiers, not role-locked domains (Luke 2026-08-24):\n\n- **Orchestrators (esther\u002Fmoses) = the intelligence layer** — decompose\n  stories → planned slices, dispatch urgent work, VERIFY every completion.\n  Strategy\u002Fresearch\u002Fverification\u002Fcase-study authoring are orchestrator work.\n- **Every other agent = a general worker** — may claim and execute ANY slice\n  (build, refactor, research, docs, infra). No role-lock.\n- A worker may claim any pending slice; **only the orchestrator may verify**.\n\n## Lifecycle\n\n```\npending → (claim) → in_progress → (report) → review → (verify) → completed\n              └── (unclaim) ──┘                    └── (verify --reject) → in_progress\n```\n\n- `review` = worker-done-AWAITING-VERIFICATION. **Not done, and nothing completes it for you.**\n  Verification is enforced in the DB rather than by convention: `tasks.verify_slice` is SECURITY\n  DEFINER with a moses\u002Festher allowlist INSIDE the function, and no other profile holds EXECUTE on\n  it — so a worker's `permission denied for function verify_slice` is permanent. It is not a retry\n  hint, and it is not a signal that someone else is about to act. The scheduled orchestrator pass\n  is what drains the queue, so **confirm that pass exists on the host** (`hermes cron list`) rather\n  than assuming the documented schedule is installed: where it is absent, paused, or never fires,\n  the slice sits in `review` indefinitely. So follow up in the SAME breath as the report — name the\n  slice id and its evidence to moses\u002Festher (bus, or escalate for a decision only the operator\n  holds) — instead of stopping at `report` and waiting. A slice stuck >24h in review gets\n  auto-re-queued by the handler's stale sweep (Arm 3) — never auto-completed.\n- **A description that names WHO may run a tool, without naming WHAT refused the caller or what to\n  do next, invites the reader to assume a passive actor will do it.** Agent-facing text (tool\n  descriptions, check messages, warnings) must state the enforcement and the next ACTION: \"only the\n  orchestrator may run this, and no job does it automatically — report, then hand the slice over\",\n  never a bare label like \"ORCHESTRATOR-ONLY\". An agent that reads the label as \"someone will pick\n  this up\" stops working on a slice nobody is coming for.\n- **The tasks store is HOST-LOCAL, so a peer's stuck slice is NOT yours to verify.** The grants are\n  per-profile roles inside EACH host's own store, so `--board --repo ALL` lists only YOUR host's rows:\n  measured, an agent elsewhere reported a slice stuck in `review` while this host's fleet-wide board\n  read `In review: none`. \"An orchestrator will clear it\" is therefore true only where a verifier\n  identity EXISTS on that host, and the drain has to be installed PER HOST — a sweep running here\n  cannot reach a peer's store, and routing their slice to a remote orchestrator is not a mechanism\n  that exists. Do not promise a peer host will act, and do not offer to verify it yourself: say which\n  host must clear it. **v017 (2026-11-08) gives the worker host's own session the sanctioned route:\n  the ORCHESTRATOR records a per-slice verify grant there (via its SSH\u002Fpsql path — the same one the\n  L2 fleet test uses to apply schema) and the worker then verifies THAT slice itself.**\n  `task-db.py verify-grant \u003Cid> --verifier mycortex_reader_\u003Cagent> --note \"\u003Cwhy>\"` — slice-scoped,\n  short-lived (1h default), one-shot (consumed on the first verify decision, approve or reject),\n  audited (authorized_by + note). **v018 (2026-11-09, operator steer \"does Titus have to ask for a\n  grant?\"): a DESIGNATED verifier needs no grant at all for work it did NOT create** — the operator\n  sets `TASKS_VERIFIER_ROLES=mycortex_reader_titus` (comma-separated) in the host env; fleet-update\n  GRANTs `tasks_verifier` every update, and the no-self-grade predicate (verify_capable_for: same\n  rule in verify_slice AND the trigger) lets that session close any dispatch with zero asks while\n  STILL refusing its own slices. The per-slice grant remains the only route for verifying your own\n  work. For a host with no verifier route at all, escalate to the operator.\n- **Widening WHO may verify WAS the schema decision, made at v017\u002Fv018 — capability + recorded\n  grants, never a config tweak.** `is_orchestrator` is now `pg_has_role(p_role, 'tasks_verifier',\n  'MEMBER')` (the NOLOGIN role is granted by default to the orchestrator reader roles; the old\n  moses\u002Festher name list is gone — adding a permanent verifier is a GRANT, a data operation, via\n  the operator's `TASKS_VERIFIER_ROLES` env). `verify_slice` EXECUTE is widened to every profile\n  role, and `authorize_verify` (orchestrator-only) records the grant row that lets a worker close\n  a slice. The reason `review` exists is intact: a designated verifier cannot grade its OWN slice\n  — every closure carries a recorded authorization (the capability excludes self-created slices —\n  created_by \u003C> profile_of(caller) — or the grant row's authorized_by + note) or falls into the\n  refused class — so DON'T bypass the grant by completing your own slice: the\n  trigger refuses review→completed on every write path unless verify_capable_for admits the\n  caller for that slice.\n\n## Worker commands (any agent)\n\n```bash\ntask-db.py list --claimable                    # the worker queue: pending slices, no assignee, by priority\ntask-db.py claim \u003Cslice-id>                    # atomic pending→in_progress, assignee=me (self-only)\ntask-db.py unclaim \u003Cslice-id> --reason \"\u003Cgap>\" # return to pending (blocker, tool gap) — never fake progress\ntask-db.py report \u003Cslice-id> --evidence \"\u003Ctest output \u002F measured numbers>\"\n                                               # in_progress→review, awaiting orchestrator verify\n```\n\n- Execute the orchestrator's PLAN (written in the slice content), don't\n  improvise strategy. Too big or lacks a tool → unclaim with the gap named.\n- Report with EVIDENCE, not prose (test output, measured numbers).\n\n## Orchestrator commands (esther\u002Fmoses only)\n\n```bash\ntask-db.py verify \u003Cslice-id> --approve --note \"\u003Cwhat was checked>\"\ntask-db.py verify \u003Cslice-id> --reject --note \"\u003Cthe gap>\"   # → back to in_progress\ntask-db.py verify-grant \u003Cslice-id> --verifier mycortex_reader_\u003Cagent> --note \"\u003Cwhy>\"\n                                                           # v017: delegate ONE slice's\n                                                           # verification to a worker-host\n                                                           # session (see delegation above)\ntask-db.py list --board                                     # counts + per-agent + review queue\ntask-db.py list --board --repo ALL                          # the FLEET view (explicit)\n```\n\n- **Never trust a self-reported done.** Verify the evidence is real (test\n  output, measured numbers) before approving.\n- Reject with the gap named — the slice returns to in_progress for the worker.\n- **Task queries are repo-scoped, STRICT by default** (2026-10-19): `list`,\n  `pending`, the claimable\u002Fhanded-out pools and `--board` show the CALLER's repo\n  and NOTHING else — untagged (pre-tag) rows are excluded, because when the store\n  is mostly untagged a scoped query returned the whole fleet backlog (the \"too\n  broad\" report from a pi session). Two explicit switches widen it:\n  `--include-untagged` (your repo + the untagged rows — use this when you are\n  scanning the pool for untagged FLEET slices) and `--repo ALL` (the\n  orchestrator's fleet-wide view; omitting the parameter is never the fleet\n  view). A session whose repo cannot be resolved gets NOTHING, by design.\n  A task you ADD with no `--repo` inherits your session repo, so it stays\n  visible in your own strict view.\n\n## Automated layers (no manual action needed)\n\n- **orch-task-morning-pass** — 07:00 KST: decompose stories → planned slices,\n  dispatch urgent via bus.\n- **orch-task-evening-pass** — 19:00 KST: verify all review slices.\n- **Stale sweep Arm 3** (agent-message-handler): review >24h → verify(false,\n  'verify-stale') re-queues to in_progress.\n- **Daily digest + board query** satisfy the visibility requirement (Luke:\n  \"1) visibility for tasks easily viewable 2) agents working truly\n  autonomously and efficiently\").\n\n## Board maintenance — \"how old is this task?\" \u002F \"should we drop it?\"\n\nTo answer age\u002Fstaleness questions, the board MCP (`task_board`\u002F`task_list`\u002F\n`task_pending`) and `task-db.py list` do NOT surface timestamps — query the\nPostgres store directly with the read-only reader role:\n\n```bash\ndocker exec -i mycortex-postgres psql -U mycortex_reader_\u003Cprofile> -d mycortex \\\n  -F'||' -c \"SELECT status, kind, priority, left(created_at::text,10) AS created, \\\n  left(status_changed_at::text,10) AS last_chg, \\\n  round(extract(epoch from now()-created_at)\u002F86400) AS age_days, left(content,60) \\\n  FROM tasks.tasks WHERE status NOT IN ('completed','cancelled') AND \\\n  (kind IN ('story','slice') OR kind IS NULL) ORDER BY created_at;\"\n```\n\n- Reader role = `mycortex_reader_\u003Cprofile>` (never superuser); container\n  `mycortex-postgres`; database `mycortex`; table `tasks.tasks`. Age columns\n  `created_at` (age) and `status_changed_at` (last state move — use this, not\n  `updated_at`, to see real movement since a row's `updated_at` updates on any\n  touch). The board's in_progress count is a snapshot; the table is the truth.\n\n**Drop decision — classify, don't mass-drop; actual deletion is the owner's call.**\n- **Parked by design** (owner explicitly deferred, or env-gated on a human\u002F\n  restart window) → keep but re-tag to `blocked`\u002F`waiting` so the board reads\n  honestly; do not burn cycles re-attempting. **Parking REMOVES the row from the\n  claim pool** — `claim` takes `pending` only — so a parked slice comes back only\n  through the parked→`pending` arc. State the unblock condition in the row, or it\n  parks indefinitely; prefer `waiting` for a genuinely external dependency, and\n  re-tag back to `pending` the moment the condition clears rather than leaving it\n  parked because nothing forced a decision.\n- **Live work just untouched** (in_progress with an assignee on an active\n  workstream, stale 1–3 weeks) → poke\u002Fre-claim the owner, never cancel their work.\n- **Sequential backlog** (slices gated on a prerequisite phase completing) →\n  normal backlog, not cruft. This binds the WORKER too: before claiming a slice, check that its\n  inputs EXIST — if every prerequisite slice is still `pending`, the deliverable can only be\n  invented, so `unclaim` with the gap named and let the queue advance in order. Do not author the\n  artifact from imagination to look productive (that is fabrication), and do not `cancel` a\n  client-facing deliverable to clear your board (the owner's call, and it destroys real work):\n  release the claim and name the prerequisite that unblocks it.\n- **Exact duplicates** (two slices describing the same deliverable) → the only\n  safe dedupe: keep the fuller plan, cancel the other, with explicit go.\n- **Scope-crossing work — CANCEL, don't improvise** (standing Luke rule). A\n  slice whose real deliverable requires changing BASE Hermes, the\n  metrics\u002Fcost telemetry pipeline, or the fleet review-pipeline automation is\n  not slice work — those belong as an explicit upstream\u002Fbase change (or\n  upstream PR), never a partial implement crammed into a task slice. Before\n  claiming a slice \"do it yourself,\" check whether its genuine deliverable\n  crosses that boundary (\"per-cron token\u002Fspend cost tagging\", \"model-tier\n  routing config\", \"auto-approve review automation\" all do). When it does,\n  `--status cancelled` the slice and flag the scope boundary for the owner\n  rather than building. Pure business research (a brand audit, a competitor\n  gap analysis) is safe to do inline — zero Hermes code.\n\n## Metadata correction — retagging a row (repo \u002F project \u002F tags \u002F assignee)\n\n`update` carries status\u002Freason only, so the ONE sanctioned surface for changing a\nrow's metadata is:\n\n```bash\ntask-db.py restore \u003Cjson>   # per row: the row's CURRENT values, with only the\n                            # field(s) you are correcting changed\n```\n\nIt writes through `tasks.task_upsert()` — the single write path. Never\n`UPDATE tasks.tasks SET repo = ...` by raw SQL: that bypasses the function's\nderivation CHECK and RLS path, and every orchestrator plan restates the rule.\n\n- **Restore PRESERVES the columns it does not carry.** `repo`, `assignee`,\n  `target`, `due`, `tags` and `correlation_id` are read back from the store and\n  re-written when your JSON omits the key; only an explicit empty value\n  (`\"tags\": []`, `\"repo\": null`) clears one. This is load-bearing: a restore\n  written for an unrelated correction used to NULL all six, so \"retag one column\"\n  was a data-loss operation and a tag could not be set after the fact at all.\n- **Read every field you DO carry out of the store; never retype it** — `source`\n  especially, because restore defaults it to `session` and a stored `manual` then\n  becomes a false statement about the row's provenance.\n- **Snapshot → probe → batch → re-read.** Snapshot the ids' full row state to a\n  file, apply ONE row and read it back, then the rest, then re-read all of them and\n  assert that no field outside the one you meant to change differs. The probe also\n  costs one row if the statement is wrong.\n- **Group legacy\u002Funtagged rows by what the ROW says, not by who wrote it.** A tag is\n  a claim about where the work lands: rows naming a file, migration, cron or doc of\n  repo X are `repo=X`; client\u002Fcontent deliverables whose output is a document belong\n  to no repo; mint-residue rows are cancels, not tags. Tagging by the writer's own\n  session repo is the false-claim version of the same mistake.\n\n## Pitfalls\n\n- **verify is orchestrator-only — and so is the ARC it performs.** Two layers, both\n  in the DB: `tasks.verify_slice` checks `profile_of(session_user) IN ('moses','esther')`\n  (workers get `false`, and no other profile holds EXECUTE on it at all), AND the\n  BEFORE UPDATE trigger `tasks.check_transition()` refuses `review → completed` for any\n  non-orchestrator caller. The second layer exists because the FIRST one was bypassable:\n  the arc itself is legal in `transition_allowed` (which is role-agnostic), so a worker\n  that could write the row — its own personal slice, whose `created_by` it is — could\n  complete it through `task_update`, `task-db.py update --status completed`, or raw SQL,\n  with no verification ever happening. Self-graded work then wore the same status as\n  verified work. Measured before the fix, on a scratch DB as a non-orchestrator role:\n  `task_upsert(p_id, p_status=>'completed')` returned a UUID (rc=0) on a row the caller\n  had just reported into `review`. Fixed in schema v014; `review → in_progress` (the\n  reject\u002Fstale arc) stays open on purpose — it asserts nothing about verification and\n  the 24h stale sweep re-queues through it.\n- **A gate whose permission is a VALUE THE CALLER WRITES is convention, not enforcement.**\n  The story gate was admitted by `tasks.transition_reason = 'story_auto_complete'` — a session GUC\n  any caller can `set_config` — so whoever could write the row could skip the gate. The fix shape:\n  the trigger VERIFIES the precondition the legitimate path satisfies by construction (a story has\n  no active slice) and ignores the reason entirely; the value keeps only its non-authorising use\n  (event labelling). Auditing a gate, ask what a caller must WRITE to pass it — if the answer is a\n  string it supplies, the gate is advisory. Note the identity check belongs in the TRIGGER, not in\n  `transition_allowed`: that function is IMMUTABLE and role-agnostic, so it cannot see a caller,\n  and removing the arc there would make the sanctioned function itself raise.\n- **`task_upsert()` PRE-CHECKS `transition_allowed()`, so a trigger rule tested through it can pass\n  VACUOUSLY — and the arcs the matrix forbids are reachable only by RAW UPDATE.** A RED test written\n  as `task_upsert(p_status=>'completed')` on a `pending` story never reaches the trigger: the\n  fast-fail raises first, \"the guard refused\" passes, and the guard under test was never consulted.\n  Put the row in the state the arc requires (e.g. `in_progress` first), and test BOTH the function\n  path and a raw `UPDATE tasks.tasks SET status='completed', \"column\"='done'` — the raw path is the\n  one the trigger actually gates. Assert the ROW STATE afterwards as well as the rc: a refusal that\n  still changed the row is not a refusal.\n- **A non-orchestrator probe role needs its own grants, and an honest worker cannot call\n  `verify_slice` at all.** v009 grants `claim_slice`\u002F`unclaim_slice`\u002F`report_done` BY NAME to each\n  profile role and `verify_slice` to moses\u002Festher only, so a scratch `mycortex_reader_\u003Cprobe>` that\n  is merely a member of `mycortex_reader` gets `permission denied for function claim_slice` until you\n  grant those three explicitly, while its `verify_slice` refusal is `permission denied` rather than\n  `false`. Assert BOTH layers — grant it temporarily to observe the in-function allowlist return\n  `false`, then revoke — or the test reports the wrong mechanism.\n- **Claim is self-only** — `p_assignee` must equal `profile_of(session_user)`;\n  you can claim only FOR YOURSELF, never assign work to others.\n- **A claimed slice can't be re-claimed** — the single claimer holds it until\n  unclaim\u002Freport.\n- **A slice that is `pending` WITH an assignee is STRANDED: unclaimable and\n  unwatched.** The pool requires `assignee IS NULL` and the row is not\n  `in_progress`, so no worker can take it, nobody is working it, and the board still\n  counts it as ordinary pending work. Assigning a slice is NOT the same as starting\n  it. Find them with `list --assigned` (MCP `task_list_handed_out`); release them\n  with `unclaim \u003Cid> --reason \"\u003Cwhy>\"`, which now clears the assignee on a PENDING\n  row as well as returning an `in_progress` one — a hand-off nobody started used to\n  be unreleasable, which is how six slices sat stuck for six weeks.\n- **A bare `pending` count overstates the queue.** It mixes claimable slices,\n  assigned-but-unstarted slices, and stories (never claimable — the pool takes\n  slices only). An actionable count is the split: `pending (claimable)` \u002F\n  `pending (assigned, not started)` \u002F `pending (story)`. A count nobody can act on\n  is what hides rot inside it.\n- **A cancel MOVES the row to `tasks.task_archive`; it does not leave\n  `status='cancelled'` in `tasks.tasks`.** So `count(*) FROM tasks.tasks WHERE\n  status='cancelled'` is 0 even when the cancellation worked — verify or audit a\n  cancel against `tasks.task_archive` (which carries `archived_at`). The live table\n  is open work only.\n- **The store is UTC; the host usually is not.** A date filter written from the\n  LOCAL calendar day is midnight UTC and silently excludes every row written earlier\n  that UTC day — a 09:00 KST change lands on the previous UTC date. Filter on a UTC\n  date or compare the timestamp, and check the boundary before believing a 0-row\n  result (a cutoff only hours away from the data is the failure shape).\n- **A migration that is not in `fleet-update.sh`'s `register()` map is NEVER\n  deployed** — the register map IS the deploy. The version-gated runner only sees\n  migrations present in the DEPLOYED schema dir, so an unregistered one leaves every\n  host silently behind while the repo looks correct. Register each migration in the\n  same change, then confirm the host reports the new version (`task-db.py\n  --apply-schema` is a no-op at the right version).\n- **The MCP status filter must accept every status the STORE uses.** An enum\n  narrower than `STATUSES` makes those rows unqueryable through MCP: they exist, are\n  counted nowhere, and cannot be asked for. Extend the tool enums in the same change\n  that adds a status.\n- **Changing what a QUERY returns is a CLASS change — sweep the writers and the\n  read-backs, not just the query.** Consumers that WRITE with one scope and then\n  READ with a filter break silently when the filter is tightened: a probe\u002Fdoctor\n  check that added its row untagged and read it back through a scoped list reports\n  a broken write path that is healthy, and a dedup guard that relied on seeing\n  those rows compares against an EMPTY set and stops guarding while still\n  \"passing\". Before shipping a scope change: grep for the add path (`cmd_add`, the\n  inbox\u002Fdream mints, every `add` invocation) and for each reader that filters, fix\n  them in the SAME cycle, and give a probe row the SAME label on the write and the\n  read-back side. A unit test on the query alone cannot see any of it.\n- **A mocked `psql` proves the call's SHAPE, not the SQL — exercise the real store\n  once before committing.** Casts and column types are invisible to a mock:\n  `p_session_id` is TEXT while `p_parent_id` is uuid in the SAME call, and an id\n  list needs `= ANY(ARRAY[?]::uuid[])` or the store answers `operator does not\n  exist: uuid = text`. Hand-writing a second copy of an existing upsert call is how\n  such a mistake happens — share ONE SQL constant across the writers, pin the casts\n  in a test that renders the SQL with sentinel values, and make the first real write\n  a probe on a single row.\n- **Unclaim\u002Fclaim\u002Freport work on YOUR OWN rows** — `created_by` must match the\n  caller; you can't unclaim or report someone else's work.\n- **Schema v009+ required** — these commands `_require_v4` (schema 9). On an\n  older host, run `bash fleet-update.sh` first; the version-gated runner applies\n  the pending migrations, and a migration missing from `register()` is never\n  carried (see the migration pitfall below).\n- **report\u002Fverify set the derivation column too** — the functions keep the\n  column-derivation CHECK in sync; hand-written UPDATEs that don't will fail.\n- **review ≠ done** — reporting puts work in a queue, it does not close it.\n  The orchestrator's evening pass is the closer.\n- **A peer reporting \"N stuck delegations \u002F nothing claimable\" is usually a\n  wrong-lane mis-route, not lost work — verify the fleet DB before\n  re-delivering.** When a worker says its queue holds delegation rows that\n  consumed with `correlation_id=None` and never became claimable, do NOT take\n  \"re-deliver the slices\" at face value (a reply that duplicates or re-mis-routes\n  is the worst outcome). Query `tasks.tasks` for the cited slice IDs first: if\n  the real rows exist and are already correctly homed (created_by=orchestrator,\n  `source=manual`, scope=`fleet`, under their owning story and the right lane),\n  the peer's copies are orphaned tracking residue from a delegation pointed at\n  the wrong agent type (e.g. content-marketing slices handed to a staging-ops\n  agent with a null correlation_id). The fix is the peer ARCHIVES its copies\n (they are not its deliverables, not claimable, not actionable) + you confirm\n the real work is intact — never a re-delivery. Judge the lane from the slice\n subject, not from the peer's framing.\n\n## Compete mode (opt-in, orchestrator)\n\nSlices can run as parallel candidates: `orch-compete-run.py \u003Cslice-id> --plan\n\"APPROACH: ...\"` (≥2 approaches). Candidates judged DETERMINISTICALLY:\nacceptance criteria met → fewest adversarial findings → lowest cost →\nfastest. Never \"which sounds better\" (consistent with O4 autonomy rules).\n\n## References\n\n- `references\u002Fv009-schema-lessons.md` — the SQL\u002FRLS gotchas behind the schema\n  (SECURITY DEFINER + session_user, column-derivation CHECK, guarded grants)\n- `docs\u002Fdesign\u002Ftask-model-v3.md` — the full design\n","# Task Queue Workflow — Task Model v3 (orchestrator-intelligence \u002F worker-execution)\n\n## When to Use\n\n- Any agent claiming or executing a slice from the task queue\n- Orchestrators decomposing stories, dispatching, or verifying completions\n- Reading the task board or daily digest\n- Design: `docs\u002Fdesign\u002Ftask-model-v3.md`; schema: `ops\u002Fservices\u002Ftasks\u002Fschema\u002F` (a version-gated runner; the highest `vNNN__` file present wins — see the migration pitfall below)\n\n## The Model\n\nTwo tiers, not role-locked domains (Luke 2026-08-24):\n\n- **Orchestrators (esther\u002Fmoses) = the intelligence layer** — decompose\n  stories → planned slices, dispatch urgent work, VERIFY every completion.\n  Strategy\u002Fresearch\u002Fverification\u002Fcase-study authoring are orchestrator work.\n- **Every other agent = a general worker** — may claim and execute ANY slice\n  (build, refactor, research, docs, infra). No role-lock.\n- A worker may claim any pending slice; **only the orchestrator may verify**.\n\n## Lifecycle\n\n```\npending → (claim) → in_progress → (report) → review → (verify) → completed\n              └── (unclaim) ──┘                    └── (verify --reject) → in_progress\n```\n\n- `review` = worker-done-AWAITING-VERIFICATION. **Not done, and nothing completes it for you.**\n  Verification is enforced in the DB rather than by convention: `tasks.verify_slice` is SECURITY\n  DEFINER with a moses\u002Festher allowlist INSIDE the function, and no other profile holds EXECUTE on\n  it — so a worker's `permission denied for function verify_slice` is permanent. It is not a retry\n  hint, and it is not a signal that someone else is about to act. The scheduled orchestrator pass\n  is what drains the queue, so **confirm that pass exists on the host** (`hermes cron list`) rather\n  than assuming the documented schedule is installed: where it is absent, paused, or never fires,\n  the slice sits in `review` indefinitely. So follow up in the SAME breath as the report — name the\n  slice id and its evidence to moses\u002Festher (bus, or escalate for a decision only the operator\n  holds) — instead of stopping at `report` and waiting. A slice stuck >24h in review gets\n  auto-re-queued by the handler's stale sweep (Arm 3) — never auto-completed.\n- **A description that names WHO may run a tool, without naming WHAT refused the caller or what to\n  do next, invites the reader to assume a passive actor will do it.** Agent-facing text (tool\n  descriptions, check messages, warnings) must state the enforcement and the next ACTION: \"only the\n  orchestrator may run this, and no job does it automatically — report, then hand the slice over\",\n  never a bare label like \"ORCHESTRATOR-ONLY\". An agent that reads the label as \"someone will pick\n  this up\" stops working on a slice nobody is coming for.\n- **The tasks store is HOST-LOCAL, so a peer's stuck slice is NOT yours to verify.** The grants are\n  per-profile roles inside EACH host's own store, so `--board --repo ALL` lists only YOUR host's rows:\n  measured, an agent elsewhere reported a slice stuck in `review` while this host's fleet-wide board\n  read `In review: none`. \"An orchestrator will clear it\" is therefore true only where a verifier\n  identity EXISTS on that host, and the drain has to be installed PER HOST — a sweep running here\n  cannot reach a peer's store, and routing their slice to a remote orchestrator is not a mechanism\n  that exists. Do not promise a peer host will act, and do not offer to verify it yourself: say which\n  host must clear it. **v017 (2026-11-08) gives the worker host's own session the sanctioned route:\n  the ORCHESTRATOR records a per-slice verify grant there (via its SSH\u002Fpsql path — the same one the\n  L2 fleet test uses to apply schema) and the worker then verifies THAT slice itself.**\n  `task-db.py verify-grant \u003Cid> --verifier mycortex_reader_\u003Cagent> --note \"\u003Cwhy>\"` — slice-scoped,\n  short-lived (1h default), one-shot (consumed on the first verify decision, approve or reject),\n  audited (authorized_by + note). **v018 (2026-11-09, operator steer \"does Titus have to ask for a\n  grant?\"): a DESIGNATED verifier needs no grant at all for work it did NOT create** — the operator\n  sets `TASKS_VERIFIER_ROLES=mycortex_reader_titus` (comma-separated) in the host env; fleet-update\n  GRANTs `tasks_verifier` every update, and the no-self-grade predicate (verify_capable_for: same\n  rule in verify_slice AND the trigger) lets that session close any dispatch with zero asks while\n  STILL refusing its own slices. The per-slice grant remains the only route for verifying your own\n  work. For a host with no verifier route at all, escalate to the operator.\n- **Widening WHO may verify WAS the schema decision, made at v017\u002Fv018 — capability + recorded\n  grants, never a config tweak.** `is_orchestrator` is now `pg_has_role(p_role, 'tasks_verifier',\n  'MEMBER')` (the NOLOGIN role is granted by default to the orchestrator reader roles; the old\n  moses\u002Festher name list is gone — adding a permanent verifier is a GRANT, a data operation, via\n  the operator's `TASKS_VERIFIER_ROLES` env). `verify_slice` EXECUTE is widened to every profile\n  role, and `authorize_verify` (orchestrator-only) records the grant row that lets a worker close\n  a slice. The reason `review` exists is intact: a designated verifier cannot grade its OWN slice\n  — every closure carries a recorded authorization (the capability excludes self-created slices —\n  created_by \u003C> profile_of(caller) — or the grant row's authorized_by + note) or falls into the\n  refused class — so DON'T bypass the grant by completing your own slice: the\n  trigger refuses review→completed on every write path unless verify_capable_for admits the\n  caller for that slice.\n\n## Worker commands (any agent)\n\n```bash\ntask-db.py list --claimable                    # the worker queue: pending slices, no assignee, by priority\ntask-db.py claim \u003Cslice-id>                    # atomic pending→in_progress, assignee=me (self-only)\ntask-db.py unclaim \u003Cslice-id> --reason \"\u003Cgap>\" # return to pending (blocker, tool gap) — never fake progress\ntask-db.py report \u003Cslice-id> --evidence \"\u003Ctest output \u002F measured numbers>\"\n                                               # in_progress→review, awaiting orchestrator verify\n```\n\n- Execute the orchestrator's PLAN (written in the slice content), don't\n  improvise strategy. Too big or lacks a tool → unclaim with the gap named.\n- Report with EVIDENCE, not prose (test output, measured numbers).\n\n## Orchestrator commands (esther\u002Fmoses only)\n\n```bash\ntask-db.py verify \u003Cslice-id> --approve --note \"\u003Cwhat was checked>\"\ntask-db.py verify \u003Cslice-id> --reject --note \"\u003Cthe gap>\"   # → back to in_progress\ntask-db.py verify-grant \u003Cslice-id> --verifier mycortex_reader_\u003Cagent> --note \"\u003Cwhy>\"\n                                                           # v017: delegate ONE slice's\n                                                           # verification to a worker-host\n                                                           # session (see delegation above)\ntask-db.py list --board                                     # counts + per-agent + review queue\ntask-db.py list --board --repo ALL                          # the FLEET view (explicit)\n```\n\n- **Never trust a self-reported done.** Verify the evidence is real (test\n  output, measured numbers) before approving.\n- Reject with the gap named — the slice returns to in_progress for the worker.\n- **Task queries are repo-scoped, STRICT by default** (2026-10-19): `list`,\n  `pending`, the claimable\u002Fhanded-out pools and `--board` show the CALLER's repo\n  and NOTHING else — untagged (pre-tag) rows are excluded, because when the store\n  is mostly untagged a scoped query returned the whole fleet backlog (the \"too\n  broad\" report from a pi session). Two explicit switches widen it:\n  `--include-untagged` (your repo + the untagged rows — use this when you are\n  scanning the pool for untagged FLEET slices) and `--repo ALL` (the\n  orchestrator's fleet-wide view; omitting the parameter is never the fleet\n  view). A session whose repo cannot be resolved gets NOTHING, by design.\n  A task you ADD with no `--repo` inherits your session repo, so it stays\n  visible in your own strict view.\n\n## Automated layers (no manual action needed)\n\n- **orch-task-morning-pass** — 07:00 KST: decompose stories → planned slices,\n  dispatch urgent via bus.\n- **orch-task-evening-pass** — 19:00 KST: verify all review slices.\n- **Stale sweep Arm 3** (agent-message-handler): review >24h → verify(false,\n  'verify-stale') re-queues to in_progress.\n- **Daily digest + board query** satisfy the visibility requirement (Luke:\n  \"1) visibility for tasks easily viewable 2) agents working truly\n  autonomously and efficiently\").\n\n## Board maintenance — \"how old is this task?\" \u002F \"should we drop it?\"\n\nTo answer age\u002Fstaleness questions, the board MCP (`task_board`\u002F`task_list`\u002F\n`task_pending`) and `task-db.py list` do NOT surface timestamps — query the\nPostgres store directly with the read-only reader role:\n\n```bash\ndocker exec -i mycortex-postgres psql -U mycortex_reader_\u003Cprofile> -d mycortex \\\n  -F'||' -c \"SELECT status, kind, priority, left(created_at::text,10) AS created, \\\n  left(status_changed_at::text,10) AS last_chg, \\\n  round(extract(epoch from now()-created_at)\u002F86400) AS age_days, left(content,60) \\\n  FROM tasks.tasks WHERE status NOT IN ('completed','cancelled') AND \\\n  (kind IN ('story','slice') OR kind IS NULL) ORDER BY created_at;\"\n```\n\n- Reader role = `mycortex_reader_\u003Cprofile>` (never superuser); container\n  `mycortex-postgres`; database `mycortex`; table `tasks.tasks`. Age columns\n  `created_at` (age) and `status_changed_at` (last state move — use this, not\n  `updated_at`, to see real movement since a row's `updated_at` updates on any\n  touch). The board's in_progress count is a snapshot; the table is the truth.\n\n**Drop decision — classify, don't mass-drop; actual deletion is the owner's call.**\n- **Parked by design** (owner explicitly deferred, or env-gated on a human\u002F\n  restart window) → keep but re-tag to `blocked`\u002F`waiting` so the board reads\n  honestly; do not burn cycles re-attempting. **Parking REMOVES the row from the\n  claim pool** — `claim` takes `pending` only — so a parked slice comes back only\n  through the parked→`pending` arc. State the unblock condition in the row, or it\n  parks indefinitely; prefer `waiting` for a genuinely external dependency, and\n  re-tag back to `pending` the moment the condition clears rather than leaving it\n  parked because nothing forced a decision.\n- **Live work just untouched** (in_progress with an assignee on an active\n  workstream, stale 1–3 weeks) → poke\u002Fre-claim the owner, never cancel their work.\n- **Sequential backlog** (slices gated on a prerequisite phase completing) →\n  normal backlog, not cruft. This binds the WORKER too: before claiming a slice, check that its\n  inputs EXIST — if every prerequisite slice is still `pending`, the deliverable can only be\n  invented, so `unclaim` with the gap named and let the queue advance in order. Do not author the\n  artifact from imagination to look productive (that is fabrication), and do not `cancel` a\n  client-facing deliverable to clear your board (the owner's call, and it destroys real work):\n  release the claim and name the prerequisite that unblocks it.\n- **Exact duplicates** (two slices describing the same deliverable) → the only\n  safe dedupe: keep the fuller plan, cancel the other, with explicit go.\n- **Scope-crossing work — CANCEL, don't improvise** (standing Luke rule). A\n  slice whose real deliverable requires changing BASE Hermes, the\n  metrics\u002Fcost telemetry pipeline, or the fleet review-pipeline automation is\n  not slice work — those belong as an explicit upstream\u002Fbase change (or\n  upstream PR), never a partial implement crammed into a task slice. Before\n  claiming a slice \"do it yourself,\" check whether its genuine deliverable\n  crosses that boundary (\"per-cron token\u002Fspend cost tagging\", \"model-tier\n  routing config\", \"auto-approve review automation\" all do). When it does,\n  `--status cancelled` the slice and flag the scope boundary for the owner\n  rather than building. Pure business research (a brand audit, a competitor\n  gap analysis) is safe to do inline — zero Hermes code.\n\n## Metadata correction — retagging a row (repo \u002F project \u002F tags \u002F assignee)\n\n`update` carries status\u002Freason only, so the ONE sanctioned surface for changing a\nrow's metadata is:\n\n```bash\ntask-db.py restore \u003Cjson>   # per row: the row's CURRENT values, with only the\n                            # field(s) you are correcting changed\n```\n\nIt writes through `tasks.task_upsert()` — the single write path. Never\n`UPDATE tasks.tasks SET repo = ...` by raw SQL: that bypasses the function's\nderivation CHECK and RLS path, and every orchestrator plan restates the rule.\n\n- **Restore PRESERVES the columns it does not carry.** `repo`, `assignee`,\n  `target`, `due`, `tags` and `correlation_id` are read back from the store and\n  re-written when your JSON omits the key; only an explicit empty value\n  (`\"tags\": []`, `\"repo\": null`) clears one. This is load-bearing: a restore\n  written for an unrelated correction used to NULL all six, so \"retag one column\"\n  was a data-loss operation and a tag could not be set after the fact at all.\n- **Read every field you DO carry out of the store; never retype it** — `source`\n  especially, because restore defaults it to `session` and a stored `manual` then\n  becomes a false statement about the row's provenance.\n- **Snapshot → probe → batch → re-read.** Snapshot the ids' full row state to a\n  file, apply ONE row and read it back, then the rest, then re-read all of them and\n  assert that no field outside the one you meant to change differs. The probe also\n  costs one row if the statement is wrong.\n- **Group legacy\u002Funtagged rows by what the ROW says, not by who wrote it.** A tag is\n  a claim about where the work lands: rows naming a file, migration, cron or doc of\n  repo X are `repo=X`; client\u002Fcontent deliverables whose output is a document belong\n  to no repo; mint-residue rows are cancels, not tags. Tagging by the writer's own\n  session repo is the false-claim version of the same mistake.\n\n## Pitfalls\n\n- **verify is orchestrator-only — and so is the ARC it performs.** Two layers, both\n  in the DB: `tasks.verify_slice` checks `profile_of(session_user) IN ('moses','esther')`\n  (workers get `false`, and no other profile holds EXECUTE on it at all), AND the\n  BEFORE UPDATE trigger `tasks.check_transition()` refuses `review → completed` for any\n  non-orchestrator caller. The second layer exists because the FIRST one was bypassable:\n  the arc itself is legal in `transition_allowed` (which is role-agnostic), so a worker\n  that could write the row — its own personal slice, whose `created_by` it is — could\n  complete it through `task_update`, `task-db.py update --status completed`, or raw SQL,\n  with no verification ever happening. Self-graded work then wore the same status as\n  verified work. Measured before the fix, on a scratch DB as a non-orchestrator role:\n  `task_upsert(p_id, p_status=>'completed')` returned a UUID (rc=0) on a row the caller\n  had just reported into `review`. Fixed in schema v014; `review → in_progress` (the\n  reject\u002Fstale arc) stays open on purpose — it asserts nothing about verification and\n  the 24h stale sweep re-queues through it.\n- **A gate whose permission is a VALUE THE CALLER WRITES is convention, not enforcement.**\n  The story gate was admitted by `tasks.transition_reason = 'story_auto_complete'` — a session GUC\n  any caller can `set_config` — so whoever could write the row could skip the gate. The fix shape:\n  the trigger VERIFIES the precondition the legitimate path satisfies by construction (a story has\n  no active slice) and ignores the reason entirely; the value keeps only its non-authorising use\n  (event labelling). Auditing a gate, ask what a caller must WRITE to pass it — if the answer is a\n  string it supplies, the gate is advisory. Note the identity check belongs in the TRIGGER, not in\n  `transition_allowed`: that function is IMMUTABLE and role-agnostic, so it cannot see a caller,\n  and removing the arc there would make the sanctioned function itself raise.\n- **`task_upsert()` PRE-CHECKS `transition_allowed()`, so a trigger rule tested through it can pass\n  VACUOUSLY — and the arcs the matrix forbids are reachable only by RAW UPDATE.** A RED test written\n  as `task_upsert(p_status=>'completed')` on a `pending` story never reaches the trigger: the\n  fast-fail raises first, \"the guard refused\" passes, and the guard under test was never consulted.\n  Put the row in the state the arc requires (e.g. `in_progress` first), and test BOTH the function\n  path and a raw `UPDATE tasks.tasks SET status='completed', \"column\"='done'` — the raw path is the\n  one the trigger actually gates. Assert the ROW STATE afterwards as well as the rc: a refusal that\n  still changed the row is not a refusal.\n- **A non-orchestrator probe role needs its own grants, and an honest worker cannot call\n  `verify_slice` at all.** v009 grants `claim_slice`\u002F`unclaim_slice`\u002F`report_done` BY NAME to each\n  profile role and `verify_slice` to moses\u002Festher only, so a scratch `mycortex_reader_\u003Cprobe>` that\n  is merely a member of `mycortex_reader` gets `permission denied for function claim_slice` until you\n  grant those three explicitly, while its `verify_slice` refusal is `permission denied` rather than\n  `false`. Assert BOTH layers — grant it temporarily to observe the in-function allowlist return\n  `false`, then revoke — or the test reports the wrong mechanism.\n- **Claim is self-only** — `p_assignee` must equal `profile_of(session_user)`;\n  you can claim only FOR YOURSELF, never assign work to others.\n- **A claimed slice can't be re-claimed** — the single claimer holds it until\n  unclaim\u002Freport.\n- **A slice that is `pending` WITH an assignee is STRANDED: unclaimable and\n  unwatched.** The pool requires `assignee IS NULL` and the row is not\n  `in_progress`, so no worker can take it, nobody is working it, and the board still\n  counts it as ordinary pending work. Assigning a slice is NOT the same as starting\n  it. Find them with `list --assigned` (MCP `task_list_handed_out`); release them\n  with `unclaim \u003Cid> --reason \"\u003Cwhy>\"`, which now clears the assignee on a PENDING\n  row as well as returning an `in_progress` one — a hand-off nobody started used to\n  be unreleasable, which is how six slices sat stuck for six weeks.\n- **A bare `pending` count overstates the queue.** It mixes claimable slices,\n  assigned-but-unstarted slices, and stories (never claimable — the pool takes\n  slices only). An actionable count is the split: `pending (claimable)` \u002F\n  `pending (assigned, not started)` \u002F `pending (story)`. A count nobody can act on\n  is what hides rot inside it.\n- **A cancel MOVES the row to `tasks.task_archive`; it does not leave\n  `status='cancelled'` in `tasks.tasks`.** So `count(*) FROM tasks.tasks WHERE\n  status='cancelled'` is 0 even when the cancellation worked — verify or audit a\n  cancel against `tasks.task_archive` (which carries `archived_at`). The live table\n  is open work only.\n- **The store is UTC; the host usually is not.** A date filter written from the\n  LOCAL calendar day is midnight UTC and silently excludes every row written earlier\n  that UTC day — a 09:00 KST change lands on the previous UTC date. Filter on a UTC\n  date or compare the timestamp, and check the boundary before believing a 0-row\n  result (a cutoff only hours away from the data is the failure shape).\n- **A migration that is not in `fleet-update.sh`'s `register()` map is NEVER\n  deployed** — the register map IS the deploy. The version-gated runner only sees\n  migrations present in the DEPLOYED schema dir, so an unregistered one leaves every\n  host silently behind while the repo looks correct. Register each migration in the\n  same change, then confirm the host reports the new version (`task-db.py\n  --apply-schema` is a no-op at the right version).\n- **The MCP status filter must accept every status the STORE uses.** An enum\n  narrower than `STATUSES` makes those rows unqueryable through MCP: they exist, are\n  counted nowhere, and cannot be asked for. Extend the tool enums in the same change\n  that adds a status.\n- **Changing what a QUERY returns is a CLASS change — sweep the writers and the\n  read-backs, not just the query.** Consumers that WRITE with one scope and then\n  READ with a filter break silently when the filter is tightened: a probe\u002Fdoctor\n  check that added its row untagged and read it back through a scoped list reports\n  a broken write path that is healthy, and a dedup guard that relied on seeing\n  those rows compares against an EMPTY set and stops guarding while still\n  \"passing\". Before shipping a scope change: grep for the add path (`cmd_add`, the\n  inbox\u002Fdream mints, every `add` invocation) and for each reader that filters, fix\n  them in the SAME cycle, and give a probe row the SAME label on the write and the\n  read-back side. A unit test on the query alone cannot see any of it.\n- **A mocked `psql` proves the call's SHAPE, not the SQL — exercise the real store\n  once before committing.** Casts and column types are invisible to a mock:\n  `p_session_id` is TEXT while `p_parent_id` is uuid in the SAME call, and an id\n  list needs `= ANY(ARRAY[?]::uuid[])` or the store answers `operator does not\n  exist: uuid = text`. Hand-writing a second copy of an existing upsert call is how\n  such a mistake happens — share ONE SQL constant across the writers, pin the casts\n  in a test that renders the SQL with sentinel values, and make the first real write\n  a probe on a single row.\n- **Unclaim\u002Fclaim\u002Freport work on YOUR OWN rows** — `created_by` must match the\n  caller; you can't unclaim or report someone else's work.\n- **Schema v009+ required** — these commands `_require_v4` (schema 9). On an\n  older host, run `bash fleet-update.sh` first; the version-gated runner applies\n  the pending migrations, and a migration missing from `register()` is never\n  carried (see the migration pitfall below).\n- **report\u002Fverify set the derivation column too** — the functions keep the\n  column-derivation CHECK in sync; hand-written UPDATEs that don't will fail.\n- **review ≠ done** — reporting puts work in a queue, it does not close it.\n  The orchestrator's evening pass is the closer.\n- **A peer reporting \"N stuck delegations \u002F nothing claimable\" is usually a\n  wrong-lane mis-route, not lost work — verify the fleet DB before\n  re-delivering.** When a worker says its queue holds delegation rows that\n  consumed with `correlation_id=None` and never became claimable, do NOT take\n  \"re-deliver the slices\" at face value (a reply that duplicates or re-mis-routes\n  is the worst outcome). Query `tasks.tasks` for the cited slice IDs first: if\n  the real rows exist and are already correctly homed (created_by=orchestrator,\n  `source=manual`, scope=`fleet`, under their owning story and the right lane),\n  the peer's copies are orphaned tracking residue from a delegation pointed at\n  the wrong agent type (e.g. content-marketing slices handed to a staging-ops\n  agent with a null correlation_id). The fix is the peer ARCHIVES its copies\n (they are not its deliverables, not claimable, not actionable) + you confirm\n the real work is intact — never a re-delivery. Judge the lane from the slice\n subject, not from the peer's framing.\n\n## Compete mode (opt-in, orchestrator)\n\nSlices can run as parallel candidates: `orch-compete-run.py \u003Cslice-id> --plan\n\"APPROACH: ...\"` (≥2 approaches). Candidates judged DETERMINISTICALLY:\nacceptance criteria met → fewest adversarial findings → lowest cost →\nfastest. Never \"which sounds better\" (consistent with O4 autonomy rules).\n\n## References\n\n- `references\u002Fv009-schema-lessons.md` — the SQL\u002FRLS gotchas behind the schema\n  (SECURITY DEFINER + session_user, column-derivation CHECK, guarded grants)\n- `docs\u002Fdesign\u002Ftask-model-v3.md` — the full design\n",{"name":5,"author":24,"version":25,"category":26,"metadata":27,"platforms":43,"description":7},"Steadfaste Fleet","1.0.0","devops",{"hermes":28},{"tags":29,"related_skills":38},[30,31,32,33,34,35,36,37],"tasks","task-model-v3","orchestrator","worker","claim","verify","review","board",[39,40,41,42],"orch-bus-worker","postgres-schema-design","loop-governance","change-test-loop",[44,45],"linux","macos","main","2e6aa8d15ab0a366c90be54f61bf9c6e97015e83","skills\u002Fdevops\u002Ftask-queue-workflow",1,"https:\u002F\u002Fgithub.com\u002Flukemcqueen\u002Fsteadfaste-fleet","steadfaste.com","https:\u002F\u002Fgithub.com\u002Flukemcqueen","AI Architect | Building Hermes Cortex: governed multi-agent AI for autonomous software engineering | Enterprise Tech Consultant","2026-11-14 22:33:34",{"source":8,"skillName":5,"commands":56,"prompt":66,"zipAvailable":67},[57,60,63],{"tool":58,"command":59},"npx","npx skills add lukemcqueen\u002Fsteadfaste-fleet --skill task-queue-workflow",{"tool":61,"command":62},"bunx","bunx skills add lukemcqueen\u002Fsteadfaste-fleet --skill task-queue-workflow",{"tool":64,"command":65},"pnpm","pnpm dlx skills add lukemcqueen\u002Fsteadfaste-fleet --skill task-queue-workflow","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Flukemcqueen\u002Fsteadfaste-fleet\u002Fblob\u002Fmain\u002Fskills\u002Fdevops\u002Ftask-queue-workflow\u002FSKILL.md",true,[69],{"path":70,"resourceType":71,"resourceTypeDesc":72,"sizeBytes":73,"sourceHtmlUrl":74},"references\u002Fv009-schema-lessons.md","REFERENCE","参考文档",4950,"https:\u002F\u002Fgithub.com\u002Flukemcqueen\u002Fsteadfaste-fleet\u002Fblob\u002Fmain\u002Fskills\u002Fdevops\u002Ftask-queue-workflow\u002Freferences\u002Fv009-schema-lessons.md",[76,84,91,98,105,112],{"skillNo":77,"name":78,"nameZh":6,"description":79,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":80,"categories":81,"keywords":82,"publishedAt":83},"01M7DXY4G8NSVB59K8B6S2AQNP","macbook-linux-maintenance","Legacy MacBook Linux fixes: GPU wedge, reboot hang, thermal.","https:\u002F\u002Fgithub.com\u002Flukemcqueen\u002Fsteadfaste-fleet\u002Fblob\u002Fmain\u002Fskills\u002Fdevops\u002Fmacbook-linux-maintenance\u002FSKILL.md",[],[],"2026-11-15 14:19:17",{"skillNo":85,"name":86,"nameZh":6,"description":87,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":88,"categories":89,"keywords":90,"publishedAt":83},"01M7DXXYJCXFJ3TGB84ZQ8KFE6","governance-regression-triage","Triage a host's governance issues: what changed.","https:\u002F\u002Fgithub.com\u002Flukemcqueen\u002Fsteadfaste-fleet\u002Fblob\u002Fmain\u002Fskills\u002Fdevops\u002Fgovernance-regression-triage\u002FSKILL.md",[],[],{"skillNo":92,"name":93,"nameZh":6,"description":94,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":95,"categories":96,"keywords":97,"publishedAt":83},"01M7DXXSAP1G8FDRJAMXQGBBMK","enforcement-immutability","Use when enforcement files lose their immutable flag.","https:\u002F\u002Fgithub.com\u002Flukemcqueen\u002Fsteadfaste-fleet\u002Fblob\u002Fmain\u002Fskills\u002Fdevops\u002Fenforcement-immutability\u002FSKILL.md",[],[],{"skillNo":99,"name":100,"nameZh":6,"description":101,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":102,"categories":103,"keywords":104,"publishedAt":83},"01M78SSDQVRYX64Y16X32TC0NS","steadfaste-fleet-repo-deploy","Use when committing to the steadfaste-fleet repo.","https:\u002F\u002Fgithub.com\u002Flukemcqueen\u002Fsteadfaste-fleet\u002Fblob\u002Fmain\u002Fskills\u002Fdevops\u002Fsteadfaste-fleet-repo-deploy\u002FSKILL.md",[],[],{"skillNo":106,"name":107,"nameZh":6,"description":108,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":109,"categories":110,"keywords":111,"publishedAt":83},"01M78SS928F3R2RJAYVW4E30CE","steadfaste-fleet-maintenance","Maintain an installed Steadfaste Fleet instance — update both the upstream Hermes Agent and the fleet repo layer, merge diverged histories, sync skills safely, and troubleshoot common issues. Covers the dual-update workflow (hermes update + fleet-update.sh), encrypted brain data backup, mycortex import, and recovery techniques.","https:\u002F\u002Fgithub.com\u002Flukemcqueen\u002Fsteadfaste-fleet\u002Fblob\u002Fmain\u002Fskills\u002Fdevops\u002Fsteadfaste-fleet-maintenance\u002FSKILL.md",[],[],{"skillNo":113,"name":114,"nameZh":6,"description":115,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":116,"categories":117,"keywords":118,"publishedAt":83},"01M78SP1CHW0T0BWE5ZT6JBPX8","fleet-preflight","DEPRECATED alias — merged into survey-before-action (2026-08-20). Load survey-before-action instead; its \"Repo-Specific Pre-Flight\" section covers git search, Hermes boundary, and deployment verification.","https:\u002F\u002Fgithub.com\u002Flukemcqueen\u002Fsteadfaste-fleet\u002Fblob\u002Fmain\u002Fskills\u002Fdevops\u002Ffleet-preflight\u002FSKILL.md",[],[]]