Skip to content
Back to skills

Complete Task

ASecurity

Complete a single named task from the named mission's TASKS_TODO.md inline in this conversation and commit it with its verified bar.

  • 3 stars
  • 0 votes
  • 0 copies
  • 0 views
  • Added November 18, 2026
ai-agentspythonshellgit

Security analysis

A100/100

Scanned November 18, 2026

npx -y skills add uHappyLogic/gurita --skill complete-task --agent claude-code

Installs into .claude/skills of the current project.

Are you the author of Complete Task?

Add the live security badge to your README. It updates with every re-scan.

Security grade badge for Complete Task
[![Security: A — Skills Directory](https://www.skillsdirectory.com/api/skills/uhappylogic-complete-task-gurita/badge)](https://www.skillsdirectory.com/skills/uhappylogic-complete-task-gurita)

More formats (shields.io, HTML) on the badges page. Keep it an A: scan every change in CI with Pro.

Download with Pro
SKILL.md
---
name: complete-task
description: Complete a single named task from the named mission's TASKS_TODO.md inline in this conversation and commit it with its verified bar.
---

# complete-task

Completes one named ad-hoc task **inline, in the current conversation** — not in a subagent
— so the work context stays in hand for follow-up.

For completing the whole task list unattended, use `/complete-all-tasks` instead.

## Invocation

```
/complete-task --mission <path> <task name>
```

`<task name>` is the full or partial text of a `##` heading in the named mission's
`TASKS_TODO.md`. The required leading `--mission <path>` names the mission by its
repo-relative path, exactly as the definition tool printed it, trailing slash included, e.g.
`mission_user-guide/`.

## Workflow

### 1. Run the shared procedure inline

First strip the leading `--mission <path>` from the invocation text by the rule in
`{{PLUGIN_ROOT}}/shared/resolve-mission.md`, holding its value as the input of the
procedure's mission resolution and reading only the rest as the task name. Read and follow
the shared procedure at
`{{PLUGIN_ROOT}}/shared/complete-procedure.md`, carrying out every step **yourself, in this conversation**,
with step 2 below run between its step 1 and its step 2, and its step 5 removal run as the one
shell call step 3 shows. Never spawn the `complete-task` agent.

### 2. Check the scope gate

Once the procedure's step 1 has resolved `<MISSION_DIR>` and located the task, and before its
step 2 loads anything or its step 3 changes anything, follow
`{{PLUGIN_ROOT}}/shared/check-scope-gate.md` for `<MISSION_DIR>`. When the gate is closed,
its report is the whole output: carry out nothing of the task, remove and commit nothing, and
print no line of step 4.

### 3. Remove and commit the completion in one shell call

Run the procedure's step 5 removal as this one fixed shell call, written out in full exactly
as shown, with only `<MISSION_DIR>`, `<Task Title>`, the bar's bullets, and the paths
replaced:

```
{ bar="$(cat)"; } <<'EOF' &&
- <criterion 1, as verified>
- <criterion 2, as verified>
EOF
if ! printf '%s\n' "$bar" | grep -q '[^[:space:]]'; then
  echo 'acceptance bar empty'
  false
fi &&
python3 {{PLUGIN_ROOT}}/tools/task_list.py remove <MISSION_DIR> "<Task Title>" &&
out="$(python3 {{PLUGIN_ROOT}}/tools/commit.py --subject "Task-completion: <Task Title>" --body "$bar" -- <recorded path 1> <recorded path 2> <MISSION_DIR>/TASKS_TODO.md)" &&
if [ -z "$out" ]; then
  echo 'completion commit landed'
fi
```

The call opens by capturing the acceptance bar, in the form the procedure's step 5 states,
from the quoted heredoc into `bar`: the heredoc feeds the `{ … }` group rather than sitting
inside the `$( )`, the form every shell parses alike whatever apostrophes or parentheses the
bar holds, and the delimiter is quoted so nothing inside is expanded (pick a delimiter line
the bar does not contain). The test that follows refuses a bar holding no non-blank line: it
prints `acceptance bar empty` and ends the call before anything is removed or committed. The
removal command is exactly the one the procedure's step 5 shows. After its `&&` the call runs
the one command of the shared commit procedure at `{{PLUGIN_ROOT}}/shared/commit-procedure.md`,
the plugin's commit tool, with `Task-completion: <Task Title>`, the full `##` heading the
procedure located, as its subject, the bar as its body, and this skill's own change set as
its paths: the exact paths the completion procedure recorded as it created or edited files
while carrying out the task, plus the mission's task list `<MISSION_DIR>/TASKS_TODO.md`
(the task left it), every path written out on the command line after `--` as its own argument
and none held in a shell variable. The tool runs the dirty-own-path guard over those paths,
stages exactly them (never `git add -A`), and commits them with them as the commit's
pathspec, so nothing else the index holds — a change another run has staged included — rides
in the completion's commit, and it repeats a git write another process's lock refused before
giving up. Its stdout is captured in `out`: empty when the commit landed, its fixed no-op line
when none of the paths changed, so `completion commit landed` is printed only when `out` is
empty and a no-op commits and prints nothing. `bar` and `out` are each one quoted value set
and used within this one call, never a tool command or a path list.

What the call prints is the whole outcome: `completion commit landed` when the commit landed;
nothing when the commit tool found none of the paths changed; otherwise `acceptance bar
empty` (nothing removed or committed — write the bar's bullets into the heredoc and run the
call again), the removal's one `Error:` line (`TASKS_TODO.md` unchanged, nothing staged or
committed — diagnose it, fix it, and run the call again), or, once the removal has landed, the
commit tool's one `Error:` line, naming the git command that failed and carrying git's own
message, with nothing committed.

### 4. Hand back

On the success path — the task was completed, verified, removed from `TASKS_TODO.md`, and
committed with its bar, the call printing `completion commit landed` — print exactly one
fixed terse status line and nothing else:

`Task completed.`

Carry no task heading, verification detail, or commit subject, and print no follow-up
pointer.

If nothing was committed because the completion was abandoned before it changed any file —
step 3's call never ran, or its commit tool found no path changed — print instead this one
fixed no-op line, not the terse success line:

```
No task completed — no file changed.
```

A task name matching no section is the procedure's own stop: its fixed line and the
available headings are the whole report. A closed scope gate is likewise the gate procedure's
own stop, its fixed line and what it printed beneath being the whole report.

Attribution

Is this your skill, or is something wrong with this listing? Request removal or report an issue. Author removals are honored within 72 hours.

View all in ai-agents →

Comments

Loading comments…

Newsletter

Get the weekly list of safe new skills, and the ones we pulled.