Przejdź do treści
Biblioteka skilli
Zarządzanie i produkt · Planowanie

yard

/yard

Prowadzi dziennik Yard gałęzi przy planowaniu, budowie, poprawkach i przeglądzie zmian, z etapami, zadaniami i decyzjami.

Repozytorium
loft ↗
Licencja
Apache-2.0
Ostatnia zmiana repozytorium
05.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
1
Przestarzałość

Brak sygnałów. Repozytorium zmienione 05.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

Co robi i kiedy

Prowadzi dziennik Yard gałęzi przy planowaniu, budowie, poprawkach i przeglądzie zmian, z etapami, zadaniami i decyzjami.

Oryginalny opis (EN)

Keep the branch's Yard Log while planning, building, fixing and reviewing a change on a git branch: its stages and tasks, the person's questions and approvals, and what each step produced and decided. Use for any work on a git branch, even where the person does not name Yard: when work on a new branch or a wave begins, when a session starts or resumes on a branch whose Yard Log is open, when a change is planned, built, fixed or reviewed, and before a branch is merged.

Jak działa

  1. The blocks
  2. Open Yard Log as the work begins
  3. Read before you write
  4. Open a stage for each step
  5. Work in another worktree
  6. Plan, then wait to be asked to build
  7. Plan at the start of each branch
  8. Make bounded tasks part of the plan
  9. Keep each task true as you go
  10. Mark the fixes the person asked for
Sekcje z nagłówków SKILL.md, w oryginale · 492 linii, 5 304 słów
Podgląd SKILL.md
---
name: yard
description: Keep the branch's Yard Log while planning, building, fixing and reviewing a change on a git branch: its stages and tasks, the person's questions and approvals, and what each step produced and decided. Use for any work on a git branch, even where the person does not name Yard: when work on a new branch or a wave begins, when a session starts or resumes on a branch whose Yard Log is open, when a change is planned, built, fixed or reviewed, and before a branch is merged.
---

# Yard Log

Yard Log is the branch's record of how its work was planned, asked about, decided and done. You
write it as typed blocks; the person reads it on the Yard page and answers and approves through
the page or a supported dialog. `loft` keeps it as YAML under `.yard/<branch>/`, and it is
committed with the work.

The host adaptation below names the operations you can call, the native actions recorded for
you, and how to present questions and plans. This shared workflow covers the stages, what each
step produced, the decisions and the reports of Loft. Use the adaptation's operations to read,
write, wait, withdraw, close and record a publish. Each result gives the revision and the page's
address; give the person the address when they ask where to answer.

## The blocks

Every block has an `id` (lowercase letters, digits and hyphens, starting with a letter) and a
`kind`. Every block but a stage names its `stage`. `after` places a block after another one; a new
block without it goes last. Writing a block again with the same id makes a new version of it,
which holds the whole block: write every field you mean to keep. Every earlier version stays in
Yard Log. A block keeps its kind and its stage, and `after` names a block of the same stage. A
block that an open submission holds cannot change: withdraw the submission first.

- `stage`: `title`, `goal` and `status` (`planned`, `active`, `done` or `dropped`).
- `note`: `markdown`, with an optional `title`, `tone` (`info`, `success`, `warning` or `danger`)
  and `folded`. Markdown only: a note holds no raw HTML.
- `question`: `prompt`, a short `header`, an optional `context` in Markdown, and two or more
  `options`, each with a `label`, a `detail` and `recommended`. Labels are unique, and a
  question with one answer recommends at most one option. `multiple` lets the person choose more
  than one option. The person can always answer in their own words as well, after the options.
- `approval`: `title` and `markdown`: something the person approves, or rejects with a reason.
- `plan`: `title`, `markdown` and, for a plan file within the tree, its `path` relative to the tree.
  Never set `planMode`: the adapter sets it on a plan presented through the host's plan mode.
- `decision`: `title`, `consequence`, and the `question` it settles, by the question's id.
- `task`: `title`, `state` (`open`, `active`, `done` or `dropped`), `detail` and `type`
  (`regular`, the default, or `fix`), with optional `assignee`: an agent's `host` and `session`,
  plus `agent` and `agentType` for a subagent.
- `loft`: a `view` of the branch's Loft specification (`spec-change`, `decision`, `trace`,
  `findings` or `publish`) and an optional `note`, in Markdown with no raw HTML. `loft` runs the
  view and keeps its report; see below.

Only the person answers and decides: never write an answer or an outcome. Only `loft` records a
`loft` block's report: never write one, and never write a `loft` block again once written.

## Open Yard Log as the work begins

Your first write on a branch opens the branch's Yard Log, titled with the branch's name. Open it
when work on the branch begins, before the work's first step: write the stages you foresee, with
the first one `active`. Each branch has its own Yard Log, so cut the branch before you write.
Yard Log, once closed, takes no more writes: more work goes on a branch of its own.

## Read before you write

When a session starts, and each time a wait returns, read Yard Log with `since` set to the
revision you last read, and take in what the person answered or decided meanwhile. The adapter
gives you the revision you last read when the session starts. Base each write on the revision you
last read, in `basedOn`. A write refused because Yard Log changed names the blocks that changed
under you: read them, then write again on the new revision.

A read gives each `loft` block's report by its size in `reportBytes`, not the report: a report
can run to hundreds of kilobytes, and the page draws them for the person. It also gives the number
of items of each list it counts in `reportCounts`, such as 45 items in `graph.diff`: check what a report
holds by its counts, and read it whole only for what they do not say. Where you need what a report
holds, read with `reports` as well as `since`, so that only the reports you need come back.

## Open a stage for each step

Before each step of the work, write a stage for it, `active`, with a goal that names what the step
leaves done ("The store reads and writes Yard Log as YAML", not "Work on the store"). When the
step ends, mark the stage `done`, or `dropped` with a note on why, before you open the next. Write
the stages you foresee as `planned`, so the person sees the road ahead.

Each agent can own one active stage. A subagent executing an assigned task keeps that task in
its recorded stage, without taking ownership of the stage or opening a stage just to execute it.
For independent work, it opens a stage of its own. A subagent that works on another branch keeps
that branch's Yard Log.

Delegate by naming the existing task's id and stage explicitly. Record its assignment, or have
the worker claim the unassigned unfinished task for itself, before execution. Give the worker
the recorded task id, stage and instructions to read Yard Log under its own caller identity.
Keep the same task through handoff: never create a second task for the delegated work. The stage
owner or current assignee can reassign or release it; other agents cannot overwrite its
assignment or execution state. Use the host adaptation's explicit binding where supported, or
write the existing task directly. A new session needs an explicit assignment or stage handoff,
unless the host adaptation says it continues an earlier one. Never infer identity from an
agent's display name.

## Work in another worktree

Your work is recorded in your working tree: the worktree whose Yard Log holds your working stage,
else your own directory. Before you work in a worktree other than your own directory, of this
repository or another, open a stage in that worktree's Yard Log by naming its tree in the write,
with its branch cut first. From then on your reads and writes, and the questions, plans, tasks
and events the adapter records for you, follow your working stage into the worktree that holds it.
Ending that stage returns the work to your own directory. Closing Yard Log and recording a publish
stay with your own directory: name the tree to close another worktree's Yard Log or to record a
publish in it. A subagent in a worktree of its own follows only its own stage, or a task assigned
to it, into another worktree.

## Plan, then wait to be asked to build

Begin no stage that builds the change unless the person asked for the build as well as the plan.
Where they asked you to plan, shape or specify the change, stop once the plan is written, and
leave the build's stages `planned`: they show the road ahead without starting down it. Tell the
person the plan is ready and that the build waits for them to ask for it. A plan the person
approved counts as asking for the build it describes, through any supported approval interface.
A question they answered does not, and a change to the specification the person approved does not
count as asking for its build: it settles what is built, not when.

## Plan at the start of each branch

When work that builds a change begins on a branch, each wave's branch included, plan the
branch's work before you write any of its code, through the host adaptation's planning
interface. Where the specification changes first, that plan is the build's plan, once the change
is approved and committed. A session that resumes or continues a branch whose plan is approved
goes on with that plan.

## Make bounded tasks part of the plan

Break each implementation plan into bounded tasks. Each task has one concrete outcome. Give
each task an explicit scope and a verifiable completion condition, such as a focused check or
an observable result. Split a task whose outcomes can be finished independently. For example,
"Reject invalid record keys" has a clear finish when the focused refusal check passes.

Once the person approves the implementation plan, register every planned implementation task
in Yard Log before the first implementation task starts. Use the host adaptation's task
mirroring when available, or write explicit `task` blocks otherwise. Put each task in its
stage, ready to be marked `active` when its work begins.

## Keep each task true as you go

Yard Log dates each task by the writes that change its state, so a task's state is only as true
as the moment it is written. Write `task` blocks yourself, or use the task mirroring described
by the host adaptation where it is available.

Either way, mark a task `active` in a write before its work starts. As soon as its work ends, mark
it `done`, or `dropped` with a reason in its `detail`. Different tasks can be active in parallel,
including tasks executed by different agents within one stage. Update each task when its own
work ends, independently of the others. An agent's end alone does not prove its task complete:
unfinished execution returns to `open`, retaining its assignee for review or reassignment. An
agent ends when its run as a subagent ends, when its session ends, or when it is interrupted;
the end of a turn of a session's main agent is not its end, and its tasks stay as they are.
After a stale refusal, reread the task and preserve the latest assignment and unrelated fields
before retrying; stop if the task was reassigned to someone else.
Never mark the tasks of a stage `done` in one write at its end: the ones not marked as they ran
show no time of their own on the page's Gantt chart.

## Mark the fixes the person asked for

A task is a fix where the person asked you to correct work already done: a fault they found, a
change they reviewed, a plan or approval they rejected with a reason. A task you take on by
yourself, a correction of your own included, is `regular`. The page marks each fix apart, so the
person sees how much of a stage went on what they asked to have put right.

To record a fix, write its `task` block with `type: fix`, or use the host adaptation's task
metadata.

## Keep one note of the issues you meet

Each stage that builds the change keeps one note, under one id such as `build-issues`, of the
issues you run into yourself during its work: failing tests, defects in existing code, wrong
assumptions, review findings. Give each issue how it was found, its fix and its state, in a
table, and write the note again as each issue is found or fixed. The note stands apart from the
plan's tasks and from the fixes the person asked for. A build plan includes keeping it.

## Ask once per decision point, then wait

Gather the questions of one decision point and send them together as one submission, rather than
ask them one at a time: write them with `send: true`, then wait on the submission
the write gave.

- Give each question a recommended option, and put the reasoning for each option in its `detail`:
  what choosing it leads to, and why you recommend the one you do.
- Use `context` for what the person needs to know to choose.
- Put an approval or a plan that belongs to the same decision point in the same submission.
- Keep option labels short so they fit the supported dialogs.

The wait operation holds the turn until the person answers on the page or in the dialog, or the
submission is withdrawn, or Yard Log is closed. Read the answers and outcomes from the wait's
result before you go on, and act on them; where the person rejected something, the reason says
what to change. Withdraw a submission that the work has overtaken rather than leave it waiting.

## Write what each stage produced

When a stage ends, write a note of what it produced: what was built or found, what it means for
the next step, and anything left open. Write the note in Markdown, with a table where things are
compared and a `mermaid` diagram where a flow or a structure is clearer drawn than told. Use a
tone where it helps the reader: `success` for a result, `warning` for a risk.

## Record each choice as a decision

Each time the person makes a choice, by an answer or a decision, write a `decision` block: the
choice as its `title`, what follows from it as its `consequence`, and the question it settles as
its `question`. Decisions are numbered in the order they are written. The page draws a decision at
the head of the question it settles, so make its consequence say what follows from the choice
rather than repeat the answer.

## Record Loft's reports, don't retell them

Where the working tree holds a Loft specification (`spec/loftspec.yaml`), record a `loft` block at
each point of the specification's work, in place of a note that retells what `loft` printed.
`loft` runs the view when you write the block and keeps its report as it was then; a later state
is a later block.

- Record a `spec-change` view once a change to `spec/` passes `loft fmt --check` and
  `loft check --fail-on warning`, whether or not it is committed: it reads the working tree. It
  compares with the base branch, the branch this one was cut from, or with the revision you give
  as `base`.
- Record a `decision` view once a decision of the specification is accepted, naming it as
  `decision` by its slug, its key or its label.
- Record a `findings` view after `loft check`, with a reason for each finding left in place, in
  `reasons`: each with the finding's `rule`, the `key` of the node it names and the `reason`.
- Record a `trace` view once the tests are linked and the links accepted. A `trace` or
  `findings` view also compares with a `base` revision when you give one.
- Record the publish with the published operation on the base branch once `loft publish` is committed
  there. `loft` publishes only on its publish branch, so the publish comes after the branch is
  merged and its Yard Log closed: name the branch whose Yard Log the merge brought in, and commit
  `.yard/` after it. It is the one block that closed Yard Log takes.

Put what the report does not say in the block's `note`: why the change is shaped as it is, or what
the person should look at. A refused `loft` block names the command that failed and why: fix the
cause rather than writing the report as a note.

## Have the spec change approved before you commit it

Where the working tree holds a Loft specification, the specification comes first and the code
after it, and the person settles what the change says before anything is planned on it. Once a
change to `spec/` passes the checks, record its `spec-change` view, then send an `approval` of the
change right after its `spec-change` block, in the same stage: its Markdown says what changed and
what the person should look at, and the block above draws the change itself.

Where the person rejects the change, the reason says what to change: revise `spec/` without
committing it, then record a new `spec-change` block and send a new approval right after it. Each
round is a new pair, so each approval stands beside the change it asks about. Commit `spec/` once
the person approves the change, and not before, alone and as one commit.

## Plan the build once the change is approved

Once the person has approved a change to `spec/` and it is committed, plan the build before you
write any code of it, even where the person asked for the build as well. Read the specification
back and present a plan worked out from what the person approved: which criteria each step
meets, and the tests that will verify them. Use the host adaptation's planning interface. The
build begins only once the person approves that plan; a plan they reject you revise with their
reason and present again.

Where the person changes a requirement once the plan is approved, commit the change to `spec/` and
record its `spec-change` view before you write any code that meets it. Plan again only the steps
whose criteria the change touches, each as it now stands. The steps of the approved plan that the
change leaves untouched stand, and are not presented again.

## Split large work into waves

Work that spans more than one subsystem, or more than eight tasks, is large. Propose splitting
it into waves in the plan of a parent branch; the person's approval of that plan approves them.
Each wave runs on a branch cut from the parent branch, with a Yard Log of its own: it plans,
builds, ends with a review and closes its Yard Log, then merges into the parent branch. The
parent's Yard Log keeps one stage for each wave, active while the wave runs and done once it is
merged. The parent merges into its own base after the last wave.

End each wave with a review of the wave's changes as its last task, run as the host adaptation
says. Fix the review's confirmed findings as `regular` tasks and list them in the stage's issue
note. Ask the person, as one decision point, about the findings you dispute or that would change
the scope.

## Commit `.yard/` with the work

Commit `.yard/` in each commit of the work, beside the code it describes. Answers the person gave
since the last commit are committed with the next, and so is what Yard keeps for each session by
itself: its token totals under `.yard/<branch>/tokens/` and its activity under
`.yard/<branch>/activity/`.

Where a read reports that git ignores `.yard/`, the repository keeps Yard Log on the machine
alone: commit nothing of `.yard/`, and never add it to a commit by force.

## Close it before the merge

When the branch's work is finished, close Yard Log with the close operation, commit the closed
Yard Log unless git ignores `.yard/`, and only then merge. Closing withdraws any submission still
open.

## Codex adaptation

Use the `loft` command line for Yard. Native hooks supply session context, record supported
activity and keep the local page server running. The plugin and a `loft` with the Codex adapter
must be installed, and the plugin's hooks enabled and trusted in Codex.

### Caller and operations

Use the identity supplied by the session hook: `--host codex --session SESSION`, plus
`--agent AGENT --agent-type TYPE` for a subagent. Keep that identity when working in another
worktree. Do not supply another caller's identity. Use `--format json` for every operation.

| Operation | Command |
| --- | --- |
| Read | `loft yard read --host codex --session SESSION --mark-read --format json` |
| Write | `loft yard write --host codex --session SESSION --input - --based-on REVISION --format json` |
| Wait | `loft yard wait --host codex --session SESSION --submission KEY --timeout 540 --format json` |
| Withdraw | `loft yard withdraw --host codex --session SESSION --submission KEY --format json` |
| Close | `loft yard close --host codex --session SESSION --format json` |
| Record a publish | `loft yard published --host codex --session SESSION --branch BRANCH --format json` |

Add your subagent arguments to each command where applicable. Pass a write's JSON batch on stdin
or through an input file; use argument arrays or correct shell quoting for values. A write's
`--based-on` is the revision you last read. On a stale refusal, read again and rebuild the write
from the new revision. Read with `--since REVISION` for changes since your last read, and add
`--reports` only when you need a Loft report in full.

The startup context is your briefing, from `loft yard read --context --mark-read`: its read is
recorded as your last, so a later read with `--since` starts from what it showed. A later prompt's
context says only whether decision notifications reach you. Read with `--mark-read` before your
first write, then base your write on that result's revision. Run the commands in your own
directory: each acts on your working tree, and `--tree DIR` names another worktree in its place,
to open a stage there or to close its Yard Log or record a publish in it. Each result reports the
tree and the page's address, and a read also reports whether git ignores `.yard/`; where it is
ignored, leave it out of commits.

### Questions and plan approval use the Yard page

Send a decision point's batch with `--send`, give the person the page address, then await the
decision by automatic monitoring or explicit waiting, below. Never treat a timeout as approval,
and never write the person's answers yourself.

Yard submissions use the page rather than native questions. Native question dialogs and native
plan approvals are not synchronized with the page. Page approval does not switch Codex out of
plan mode or grant permissions: Codex's mode and permissions still govern what you may execute.
When the host prevents a required write, explain the constraint and keep the plan in the
conversation until the host permits that write.

### Automatic decisions and explicit waiting

Session context reports whether decision notifications are available, unavailable or uncertain.
When decision notifications are available, you may end your turn after sending the submission.
The adapter's worker monitors fully resolved submissions and notifies your already loaded
native thread when a decision arrives; automatic monitoring fulfills the shared workflow's wait.
Do not keep the agent polling or keep a turn alive just to await the person.

When availability is unavailable, uncertain or not reported, wait with `--submission` set to the
returned submission key. A wait that returns `pending` after 540 seconds has no answer yet:
read what changed, then wait again while the decision is needed. If automatic monitoring becomes
unavailable while you are active and a decision is still needed, use this explicit waiting
fallback. Neither availability nor the end of a turn is an approval.

An adapter notification identifies the Yard Log, tree, branch, submission and resolution revision;
it is not a new approval. Before acting, read with `--mark-read` using your supplied caller identity
in the named tree and take the authoritative counted answers and outcomes from Yard. A retry
after uncertain delivery may produce an exceptional duplicate notification: make a fresh Yard read,
check what work is already done, and do not repeat completed work because another ping arrived.

Interruption or session end disarms automatic continuation. A later genuine user prompt can rearm
monitoring; an adapter-generated notification cannot. Normal turn completion leaves monitoring armed.

### Planning workflow

This workflow is adapted from [OpenAI Codex's Plan mode prompt](https://github.com/openai/codex/blob/rust-v0.164.0/codex-rs/collaboration-mode-templates/templates/plan.md)
at release `rust-v0.164.0`, Copyright 2025 OpenAI, licensed under Apache-2.0. Its questions,
plan presentation and completion boundary are adapted for Yard. No prompt in this skill changes
Codex's native collaboration mode.

Use this workflow when the person asks for a plan, at the start of each branch that builds a
change, waves included, and for the build plan required after specification approval and its
separate commit. At a branch's start, suggest that the person switch Codex to Plan mode; the
suggestion changes no mode. A changed requirement needs a plan for only the steps it affects.
Keep implementation stages planned until the person has approved their plan and native mode
permits their build. A wave's closing review runs `codex review --base PARENT`, naming the parent
branch; work through what it reports as the shared workflow says.

#### Planning boundary

Do not implement the change while planning. In particular, do not edit product files,
specifications or tests, apply patches, run migrations or code generation, run rewriting
formatters, or commit the implementation. Explore through reads, searches, static inspection
and dry runs. Focused tests or builds may write caches and build artifacts when they establish
facts needed for the plan and respect the person's testing limits.

Yard planning records are the only writes this workflow permits: planning stages and their
tasks, questions, approvals, plans, notes and decisions, plus the build's stages left `planned`.
Native mode and permissions still govern those writes. If native Plan mode prevents a Yard
write, keep the plan in the conversation and explain that the person must change the native
mode before it can be recorded. Never bypass that limit or claim that page approval changed
the mode.

`update_plan` is an execution-progress checklist: it does not enter or exit native Plan mode,
present a reviewable build plan or approve it. Do not use it to start implementation tasks while
planning. Once the build is approved and permitted, use the task-mirroring workflow below.

#### 1. Explore the repository

Explore before asking about discoverable facts. Read the relevant specification, implementation,
entry points, configuration, schemas and tests. Check the existing behavior and constraints with
targeted non-mutating commands. Resolve facts the repository can supply rather than asking the
person to locate code or choose something the existing implementation already establishes.
Ask before exploration only when the request itself has an obvious contradiction or ambiguity
that exploration cannot settle.

#### 2. Clarify intent

Establish the goal and success criteria, who the change serves, its scope, constraints and
material tradeoffs. Separate discoverable facts from the person's preferences. Resolve the
high-impact uncertainties before choosing an implementation approach.

Required questions go through Yard submissions: group one decision point's questions, give
meaningful options with a recommendation and its reasoning, send them together and wait for the
answers as described above. Ask only questions whose answers affect the plan or settle an
important assumption. Do not replace an unanswered required decision with an assumed default.
Record low-impact defaults that need no question as assumptions in the plan.

#### 3. Resolve implementation

Work out the interfaces and data flow, failure cases, compatibility and migrations, verification
and acceptance criteria, and any rollout needs relevant to the change. Tie the implementation
steps and tests to the approved specification's criteria where one exists. Ground the approach
in the repository and make the material implementation choices explicit. Continue exploration
or send another decision point's questions when a required choice is still open.

#### Present the plan and wait

Present one complete `plan` block with `title` and `markdown` once no material decisions remain
for the implementer. Keep the plan concise but complete: summary, implementation steps,
interfaces, tests and assumptions. Group steps by behavior or subsystem rather than listing
every file. Include risks and compatibility or rollout work where they affect implementation.

Submit the plan with `--send`, give the person the Yard page address, then await and read the
outcome using automatic monitoring or explicit waiting above. Leave the build's stages `planned` and wait for approval
before implementation. No question answer, timeout or native plan rendering counts as Yard plan
approval. An approved Yard plan authorizes only its described build when native mode and
permissions allow it.

Revise a rejected plan as a complete replacement, addressing the person's reason, and send it
in a new submission for approval. Withdraw any superseded submission that is still pending.
Do not present an incomplete replacement as the final plan.

Do not put `<proposed_plan>` tags in the Yard plan's Markdown. Where actual native Plan mode
requires that presentation in the conversation, follow the host's instruction there; that
presentation does not synchronize a native approval with the Yard page.

### Plan steps and reporting limits

The adapter mirrors successful `update_plan` calls into your working stage, the one your briefing
names: the stage of your active assigned tasks, else your own active stage, else your session's
main agent's active stage. Open your active stage before using `update_plan` where you have none
of these. It maps pending steps to open tasks, in_progress to active, and completed to done.
It identifies steps by exact text and duplicate occurrence: reordering retains their identities;
renaming creates a new task and drops the old unfinished task. Removed completed tasks stay done.
Do not duplicate these tasks in explicit writes.

When Codex does not offer `update_plan`, write Yard task blocks yourself. For a fix, run
`loft yard task TASK-ID --type fix` with your caller arguments, which changes that field alone,
or read the mirrored task and write its whole block with `type: fix`; later mirrors retain that
classification.
Unbound steps need a working stage: none is mirrored while your active assigned tasks lie in more
than one stage. A step mirrored into a stage you do not own is assigned to you. Keep stages,
notes, decisions and Loft reports yourself.

For delegated work, claim or assign the existing task through a normal Yard write first. Use
its exact ID as the prefix of every bound native step: `[yard:TASK-ID] Local checklist wording`.
The adapter updates that task in its original stage without creating another task or requiring
a worker-owned stage. The prefix binds identity; the wording does not rename the task. Retain
the prefix on every update. Unknown, malformed or duplicate bindings create no replacement;
removing a bound step leaves the task unchanged. Another assignee's progress and terminal
delegated tasks are preserved.

An identified end or interruption returns your still-active assignments to open, retaining their
assignee and execution history; it never implies completion. A subagent's stop, an interruption
and the session's end each count. The main agent's `Stop` at the end of an uninterrupted turn
does not, and leaves them active. A new start permits progress again; late native updates from an
ended worker are ignored. Ambiguous actor identity changes no task. A new Codex session does not
continue an earlier one: it needs an explicit assignment or stage handoff.
Startup context lists your assigned task IDs and original stages separately from your own stage;
read Yard Log for any assignments omitted from that bounded context.

Native hooks carry no token counters. During an identified native turn, the worker observes
latest-request usage from an already running local Codex app server over its Unix-domain
WebSocket. It uses `$CODEX_HOME/app-server-control/app-server-control.sock`, or the same path
under `~/.codex`. The person selects another local socket by giving
`loft yard codex watch --app-server-socket ABSOLUTE_PATH` in the plugin's hooks; never change
hooks yourself to select one. It starts no Codex process and changes no configuration, collaboration mode or
permissions. The prompt hook waits at most 500 milliseconds for readiness; an absent server,
an unready new thread or an observation gap leaves usage unavailable or partial. It disconnects
when the turn ends, and reconnecting imports no historical token totals.

Fresh input excludes cached input, cached input is cacheRead, and output already includes
reasoning output. An absent cache-write counter stays unavailable. Zero cache writes from ChatGPT or unclassified
sources are unavailable. Verified API-key zeros and positive reported counts remain measured.
Raw source values are preserved in machine events and accounting checkpoints. Historical Codex
zeros without verified provenance are unavailable on the page; their source files are unchanged.
Native activity and
heartbeats continue without the usage source, and an unreported tool outcome stays unknown.
During concurrent subagent work, activity without a reliable agent identity is omitted.
The adapter does not parse transcripts. Its heartbeat worker has a 24-hour lifetime;
later hooked activity restarts a worker that ended. The integration supports local Codex
workflows; cloud orchestration does not run these plugin hooks.

Wersje

RepozytoriumWynikLicencja
Ta strona · ask-loft/loft100Apache-2.0
ask-loft/loft100Apache-2.0
ask-loft/loft100Apache-2.0

Migawka bazy z 13.11.2026 · wersja paczki 8fb5f3c6cf2b (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100switchyard
    Dodaje i poprawia zadania w manifestach .yard.toml na tablicy Switchyard i diagnozuje zadania zakończone czerwonym statusem.
  • 91yard-management
    Optymalizuje operacje na placu manewrowym: parkowanie naczep, śledzenie naczep, program naczep pozostawianych, pula naczep, obsługa bramy i wykorzystanie bram dokowych.
  • 91dock-door-assignment
    Optymalizuje przydział bram dokowych, harmonogram przyjazdów ciężarówek i zatłoczenie placu, w tym umawianie okien czasowych.
  • 90map
    Wskazuje, który ze skilli odpowiada za zadanie w kolejności pętli dostarczania, bez jego uruchamiania.
  • 90map
    Wskazuje właściwy skill dla zadania, gdy nie wiadomo, który z dostępnych skilli się nim zajmie, w kolejności pętli dostarczania.
  • 84document-code
    Rozstrzyga, czy komentarz ma sens, i pisze te potrzebne w Ruby, YAML, Dockerfile, skryptach powłoki, testach i konfiguracji, w tym docstringi i bloki YARD.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.