---
name: take-ownership
description: "Own current work through delivery and smoke verification, finish loose ends, reconcile records, and clean task-owned Git state. Use to resume delivery, follow up after merge or deploy, check what remains, close off, wrap up, or finish up."
argument-hint: "[work item, pull request, or branch] | close [target]"
license: MIT
title: take-ownership
canonical_url: https://skilld.dev/gh/harlan-zw/harlan-agent-kit/take-ownership
last_updated: 2026-10-12T14:01:05.000Z
---

> Index of every page on this site: [llms.txt](https://skilld.dev/llms.txt)

> **Skill from skilld.dev.** Follow the user's requested action.
> If the user asked to fork this Skill, follow the fork workflow below. Do not execute the Skill instructions while copying it.
> Otherwise, follow the instructions below for this session. You do not need to install anything.
>
> Supporting files, fetch one when the Skill refers to it: [agents/openai.yaml](https://skilld.dev/api/skills-raw/harlan-zw/harlan-agent-kit/take-ownership/agents/openai.yaml), [references/completion.md](https://skilld.dev/api/skills-raw/harlan-zw/harlan-agent-kit/take-ownership/references/completion.md).
>
> If the user asked to install this Skill, run `npx skilld install harlan-zw/harlan-agent-kit/take-ownership`. Install writes the Skill files into the project, so every session loads them.
>
> ## Fork workflow
>
> A fork creates an editable local Skill with its original author and licence. The request authorizes copying and local installation.
> 1. Check `./skills/take-ownership`, the project lockfile, and selected Agent targets together. If the local directory or installed Skill exists, stop. Never overwrite an existing directory or Agent target.
> 2. Read [source metadata](https://skilld.dev/api/v1/skills/harlan-zw/harlan-agent-kit/take-ownership) once. Use sourceUrl, sourceCommit, skillPath, sourceGone, and license. If the source is gone or its path is missing, stop. If license is null, read licence files at the source commit.
> 3. Fetch only the source commit into a temporary Git repository. Do not clone full history. Derive repository_url from sourceUrl, including repository renames. If sourceCommit is absent, resolve the sourceUrl ref once. Set source_commit to that actual commit. Run these commands in one shell call:
>
> ```sh
> git init --quiet "$temporary_dir"
> git -C "$temporary_dir" fetch --quiet --depth=1 "$repository_url" "$source_commit"
> git -C "$temporary_dir" checkout --quiet --detach FETCH_HEAD
> ```
>
> Read applicable licence declarations and notices at that commit. If copying is not permitted, report the restriction and stop.
> 4. Inspect source entries together, then copy the directory containing skillPath into `./skills/take-ownership`. Use the user's path if selected. Keep the original SKILL.md, relative links, scripts, binary assets, and executable modes. Exclude .git metadata. Reject symlinks and paths outside the Skill directory. After checking entries, use cp -a where available. A regular source directory needs no custom copy script. Do not save this page wrapper as SKILL.md.
> Preserve author credit, notices, and applicable licence files from repository or parent directories. Add PROVENANCE.md with the Skill page, source URL, actual commit, original path, and licence. Retain any existing PROVENANCE.md and record new provenance separately. Batch source inspection, copying, and provenance work where practical.
> 5. In the project root, run `skilld install ./skills/take-ownership --mode copy --plain`. If skilld is unavailable, use `npx skilld install ./skills/take-ownership --mode copy --plain`. This known command needs no help lookup. Install does not support --json. Use detected Agent targets, or add --agent for the targets the user selected. Install the local path, never the upstream selector. If installation fails, preserve the local copy and report the exact failure.
> 6. Confirm the local lockfile source and installed Agent copies once. Report the local path, actual commit, and Agent targets. After edits, reinstall the same local path. Upstream updates must not replace it. Do not publish or push unless the user asks.

# Take Ownership

Stay responsible for one current work item until its intended result is `VERIFIED`, `BLOCKED`, or `CANCELLED`.

A commit, green CI, or merge remains intermediate when later delivery stages apply.

## Select mode

Resolve one current work item from the conversation and `$ARGUMENTS`.

| Request | Mode | Next step |
| --- | --- | --- |
| Own, resume, land, or follow current work through delivery | Delivery | Start ownership below. |
| What remains, follow-up, close off, wrap up, or finish up | Completion | Read [completion](https://skilld.dev/api/skills-raw/harlan-zw/harlan-agent-kit/take-ownership/references/completion.md). |
| `close` followed by a work item, pull request, or branch | Completion | Read [completion](https://skilld.dev/api/skills-raw/harlan-zw/harlan-agent-kit/take-ownership/references/completion.md) for that target. |
| Work has delivered and needs records or cleanup | Completion | Read [completion](https://skilld.dev/api/skills-raw/harlan-zw/harlan-agent-kit/take-ownership/references/completion.md). |

Completion mode resolves remaining work before cleanup.
For related gaps, opportunities, or improvements, use [i-dont-know-just-keep-working](../i-dont-know-just-keep-working/SKILL.md).
For a bare "what's next", check required completion work before proposing expansion.
If delivery remains required, follow the Delivery sections below, then return to the same completion ledger.
Preserve the target, evidence, and original authority when changing modes.
Do not restart target selection or create another watcher.

## Authority

Completion requests authorize safe cleanup of task-owned integrated Git state.
They grant no merge, issue mutation, publication, or unrelated delivery authority.
Skill selection, mode selection, and generated default prompts never grant merge authority.
Use the mutation authority contract for every merge decision.

## Use existing contracts

Read these completely when they apply:

1. `../pr/SKILL.md` for pull request creation, updates, CI, and review feedback.
2. `../adversarial-review/SKILL.md` for readiness.
3. `../adversarial-review/references/mutation-authority.md` for mutation and merge authority.
4. `../unit-tests/SKILL.md` before repairing behavior or validation.
5. `../../references/worktree-isolation.md` before local mutation or cleanup.

Follow repository instructions and delivery configuration. Use `dev-browser` for browser smoke tests.

Before browser work, read [browser](../browser/SKILL.md).
Verify the intended Chrome profile and the target site's signed-in identity.

Delegate detailed permissions, review gates, worktree isolation, and publication to those contracts.
Use [completion](https://skilld.dev/api/skills-raw/harlan-zw/harlan-agent-kit/take-ownership/references/completion.md) for the closure ledger and cleanup proof.

If `harlan-github-agent` already controls the repository, resume its existing worker. Do not start another watcher.
Interactive submitting Agents may subscribe with [pull request watching](../pr/references/pull-request-watch.md).
That CLI reads the existing observer. It does not create another scheduler or GitHub polling loop.
When the CLI returns `Merged`, continue Completion for that exact target without waiting for Harlan to repeat the merge.

## Start ownership

Inspect local Git state and remote state. Select one exact target:

- `LocalWork`: current uncommitted or unpushed work.
- `PullRequest`: one open pull request and its exact head commit.
- `Revision`: one pushed commit without an open pull request.

Determine the intended result and applicable CI, merge, deployment, release, and smoke stages.

A Markdown-only pull request runs no CI unless a workflow event uses `paths` to include that Markdown.
After its merge, verify the merge commit on `origin/main` instead of a green check.

Ask only when multiple targets remain plausible or the intended result materially changes the work.

Keep the exact commit and delivery targets attached to ownership.

Record the user's exact action authority for the resolved target.

Pass that evidence to mutation authority. Ownership and completion requests alone never grant merge authority.

## Complete and review

Complete local work with the relevant domain skills and verification.

Use `pr` when code needs review. Use `adversarial-review` before deciding readiness.

Restart readiness after the remote head changes.

If `pr` uses the capacity fallback, finish the independent assessment and current-head CI.
That fallback stops the exact-head Service Review and cancels its queued Task.
Report the assessment, stopped Service Review, and outstanding human decision. End the interactive wait.
Do not await the cancelled Task or request another Review for that stopped head.
An independent assessment does not satisfy the `READY` merge gate or grant merge authority.
Retain ownership of the target for the human decision or a new head.
Do not report `VERIFIED` before all applicable delivery and smoke stages complete.

If an active Service Review or Repair Task still owns the work, hand off to that durable Task.
Name its exact state and next action. Never edit while its Repair Task is active.

## Land and follow

When authority permits, land the exact ready head through the repository's normal merge path.

If the current head qualifies for automatic merge, follow the PR Skill's foreground watch through merge and Completion.
If only Harlan's merge decision remains, follow the PR Skill's ready pull request handoff and end the turn.
Retain the exact target and delivery evidence. Resume when Harlan reports a merge or requests follow-up.
If Harlan requests an active wait for that decision, use a foreground merge watch.

Follow the exact commit through every applicable delivery stage. Do not infer delivery success from unrelated green checks.

If newer work supersedes the target, explicitly adopt its commit or cancel ownership with evidence.

## Repair and recover

Prove a failure belongs to the owned change before editing.

Add a failing test first for behavior or validation regressions. Apply the smallest useful repair and verify it.

Use `chore: <specific problem>` for CI or delivery pipeline repairs. Use `fix:` for deployed product behavior.

Use the task branch for pre-merge repair. After merge, open a focused repair pull request from the current remote default branch.
Never push directly to the default branch.

If production remains unsafe, choose the safest viable recovery: repair, rollback, or block with evidence.

Keep trying while meaningful progress remains. Block after three failed repairs for the same cause.

## Smoke and close

Verify the result against a meaningful target and assertion.

For browser targets, check health, changed behavior, console errors, and one relevant critical path.

If smoke finds a regression, return to repair.

Update the existing marked comment or durable record. Preserve delivery and smoke evidence.

After smoke, follow [completion](https://skilld.dev/api/skills-raw/harlan-zw/harlan-agent-kit/take-ownership/references/completion.md) to finish loose ends, reconcile records, and clean task-owned state.
Close only as `VERIFIED`, `BLOCKED`, or `CANCELLED`.

Continue while authorized CI, automatic merge, deployment, release, or smoke work can progress.
If only Harlan's merge decision remains, use the PR Skill's handoff instead of keeping the turn active.
