SkillAgentSearch skills...

long-task-callback

Submit durable Codex, Claude, Pi or DeepSeek Harness child agents using registered task templates, or arrange callbacks for long-running commands, training, benchmarks, tests, builds and data jobs

Install / Use

npx skills add lz59970062/long-task-wakeup

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

71/100

Supported Platforms

Claude Code
OpenAI Codex

Tags

Our assessment of long-task-callback

long-task-callback scores 71/100 on our quality scale, 3863rd of 4,698 Development & Engineering skills we index.

Its SKILL.md is 39 KB long, well organised into 29 sections with 15 code examples: long enough that it reads more like full documentation than a focused instruction file, which agents can find harder to follow.

It has no GitHub stars yet, so there is no community track record; judge it on its content.

Substance
21/30
Structure
20/20
Description
15/15
Adoption
0/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated 13 days ago, so long-task-callback is actively maintained.
  • No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
  • Its trust signals score 80/100, with 2 cautions from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-11-16. Automated pattern scan on 2026-11-16. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

long-task-callback compared with similar skills

All 4 of these similar skills score higher than long-task-callback; compare them before choosing.

SkillScoreStarsUpdatedFormat
long-task-callback (this skill)by lz5997006271013d agoSKILL.md
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
ai-job-searchby ai-job-search-dev10072.1ktodayCLAUDE.md
claude-howtoby luongnv8910047.3k2d agoCLAUDE.md
lobehubby lobehub10085.6ktodayMCP Server

Frequently asked questions

How do I install long-task-callback?
Run npx skills add lz59970062/long-task-wakeup. The install tabs above show the steps for each supported agent.
Which AI agents does long-task-callback work with?
It is written for Claude Code and OpenAI Codex, as a SKILL.md file. Other agents that read the same format can often use it too.
Is long-task-callback safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It declares no license and scores 80/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is long-task-callback still maintained?
The repository was last updated 13 days ago, so long-task-callback is actively maintained.

name: long-task-callback description: Submit durable Codex, Claude, Pi or DeepSeek Harness child agents using registered task templates, or arrange callbacks for long-running commands, training, benchmarks, tests, builds and data jobs. Use when independent task ownership or a return to the original Codex, Claude Code, PI Agent or DeepSeek Harness session is needed. Repair LTC configuration status blocks; inspect results, ACK callbacks and continue the original goal.

Long Task Callback

Rule

Use an explicit callback when requested or when a command may outlive the current Codex or Claude Code turn.

There are three public workflows:

  • ltc run -- <command> submits a new long-running task. The daemon launches it through an independent task owner (systemd on Linux, launchd on macOS, Task Scheduler on Windows; screen fallback on Linux/macOS).
  • ltc agent codex|claude|pi|dsh -- <prompt> submits a fresh child agent through the same durable lifecycle. Codex/Claude are available since 0.6.5; Pi is a child worker and callback parent in the current preview.
  • ltc done ... queues a completion callback for work already owned by screen, tmux, Slurm, another scheduler, or an existing script.

Daemon handoff is unconditional and requires no opt-in flag. Never add --via-daemon to newly written commands; old scripts may still pass it as a hidden no-op compatibility flag. Do not invent another public launch flag or a direct-mode flag. Do not use a direct recursive codex exec resume or claude -p --resume call from an agent tool sandbox. Do not let callback behavior change the task's original exit code unless the user explicitly requests --strict.

Registered task templates

ltc template register NAME --file /path/to/template.yaml installs a user template, copies its system-prompt dependencies, and creates a short ltc-NAME discovery skill. The YAML's worker and description describe the capability; CLI options can supply or override them. ltc template list --json shows the registered capabilities. The generated entrypoint binds the installed template file so another workspace's LTC_TEMPLATE_DIR cannot select a different same-named template. Keep Agent profile settings and the current parent's callback binding.

Read the matching entrypoint and pass actual task scope, target paths and evidence constraints. Check readiness with ltc doctor --operation agent --agent-worker WORKER and validate submission with --dry-run when needed. Routine local edits need not be delegated. On completion, inspect the real result and edits, ACK and continue.

Registration maintains only the following index; preserve the surrounding instructions.

<!-- ltc:registered-templates:begin --> <!-- ltc:registered-templates:end -->

Callback rules that always apply

Callback modes (0.7.1 preview)

--callback-mode auto recognizes the current Codex Desktop origin marker and selects codex-queue; other origins select cli. Use an explicit mode if the host omits that marker. A historical session source is not its current owner. codex-queue runs the public codex queue --thread UUID --message TEXT once with the submitting session's environment. It needs no launcher, shared Core or restart, and never falls back to a second writer. A Codex without that command refuses a new run or agent before task admission. done still preserves completed work.

A queued message is not a received one. The callback stays pending until the chat runs its ACK, and ltc status says it is waiting. It does not hold back later callbacks for that thread. The ACK runs under the chat's own permissions: if the sandbox blocks it, request approval to run the same command. Nothing is sent again. A rejection (codex queue reported an error, or could not start) is in failed with the cause: fix it, then ltc retry --id ID. A kill, timeout or unreadable success is an unknown outcome and retry is refused, because the message may be in the chat: inspect the chat, then ltc ack or ltc cancel. Never resend it by hand.

manual explicitly saves results/callbacks for later receipt and does not start an Agent automatically. Choose it only when the user accepts this limitation.

The Desktop launcher is retired: --callback-mode desktop is refused for new work, ltc desktop only explains the replacement, and setup generates no launcher. A saved desktop callback keeps its results and route; if it is blocked, move it with ltc retry --id ID --callback-mode codex-queue, which does not rerun the workload.

Read doctor's separate callback field. owner_reachable is a read-only observation, not proof of end-to-end receipt. Sandboxed tools may need authorized ordinary-user execution to inspect native peers; never weaken identity checks. After repairing a known failed handoff, ltc retry --id ID requeues the original callback without rerunning its workload. Unknown submission outcomes, active deliveries, ACKs and cancellations prevent ordinary retry. Inspect manual results in the bound session before ACK, and label that receipt as manual rather than a successful autonomous callback test.

Upgrade the coordinator before using new task records v3 and v6 / callback records v2 and v5. Older daemons deliberately reject them instead of dropping callback-mode intent, and keep the record; ltc retry delivers it after the upgrade.

On every callback, inspect the result and relevant artifacts, decide whether the original goal is complete, blocked, or needs another action, and continue when the next step is clear and safe. Inspect existing work before relaunching it. Then run the supplied ACK command; ACK confirms receipt, not completion of the overall goal. Resume only the bound conversation, never redirect to --last or another session.

Read the user callback hook at initial LTC use when present. Its instructions still apply when not repeated. Since LTC 0.6.6, standard reminders appear on the first callback and every 4 distinct callbacks thereafter; user-hook reminders on the first and every 3. A short callback omits repeated prose, not these responsibilities. Task results, routing and the ACK command remain present. In 0.7.0, full commands, timestamps and handoff text are saved at the supplied Details path. Read that file before acting when the envelope says so; otherwise inspect relevant result artifacts directly. An exit code is process status, not proof of test success. When reporting a callback to the user, include the recorded task runtime in one short phrase when available, such as Finished in 2m 5.5s. Use execution duration, not the time spent waiting for delivery; do not invent a duration when it is unknown.

Configure with ltc prompt-policy --system-every 4 --user-every 3; no options shows the effective policy. 1 means every callback. The file is ${LTC_HOME:-~/.ltc}/callback-prompts.yaml. Counters are per queue, agent and bound session, allocated at first delivery attempt. Retries reuse the same sequence and reminder decisions across restarts. Queuing/dry-run does not count. An unsafe --last target keeps full reminders because its identity is unknown.

Ownership invariant

The 0.7 topology separates the coordinator and task owners:

systemd user service / macOS LaunchAgent / Windows login task -> ltc daemon (recovery and callbacks)
independent systemd service / launchd job / Windows scheduled runner -> LTC worker -> command / child agent

--backend auto prefers an available systemd user manager (v240+) on Linux or the logged-in GUI launchd domain on macOS, otherwise screen on those platforms. On Windows it selects windows-task, using Task Scheduler in the logged-in user session and a runner-owned Job Object. --backend systemd, --backend launchd or --backend windows-task requires that native manager; --backend screen explicitly selects the compatibility backend. Existing screen tasks retain their owner. The native backend needs no screen. A screen process can remain inside its launching service's control group: do not assume it survives stopping that service.

After submission, record the task ID, execution backend and artifact paths, then return control when no independent work remains. For long work, avoid polling processes or logs on a timer. Live monitoring is appropriate when requested or diagnosing callback infrastructure. Do not change a running task's owner or automatically retry an unknown native launch. DSH callbacks are live-only and use the same native launch path as the other agents.

Duration policy

Choose the execution path before launching the command:

  • If the command is reliably expected to finish within 60 seconds, one foreground wait is acceptable.
  • If it may take about one minute or longer, its duration is uncertain, or a second status check might be needed, use ltc run from the start.
  • Do not keep a prompt cache warm by polling. A few-minute task should normally use callback delivery: the daemon and screen wait without model turns, then resume the same conversation when work completes; ACK and existing-artifact checks handle possible duplicate delivery.
  • If intermediate results genuinely require agent decisions, use sparse milestone callbacks rather than timer-based status polling.

If a supposedly short foreground command unexpectedly remains active, keep the current turn responsible for it; do not abandon it as an agent-owned background process.

The command name is ltc; codex-long-task-wakeup remains a compatibility alias.

Install

Automatic configuration checks

ltc run, ltc agent and ltc done automatically check LTC's supported environment, configuration and observed runtime chain: storage, coordinator, recorded task owners, saved results and callback handoff. These checks follow the selected platform adapter and each task's recorded backend, not a fixed list of software to install on every host. Healthy calls add no diagnostic text. A failed check appends a JSON block between [ltc-status] and [/ltc-status] on stderr. This is an action request to the calling Agent: diagnose the listed issues, configure LTC in the current environment, run its recheck_command, then continue the user's task. Do not hand ordinary installation, service startup or configuration commands back to the user.

The block supplies repair_command and recheck_command as argument arrays pinned to the current LTC installation and queue. Address missing prerequisites first; preserve the original Agent session, profile paths and existing custom settings. Read environment, checks.configuration, checks.runtime and each issue's kind/code to distinguish missing setup from a runtime fault or unsupported OS. repair_command can be null: an absent task owner or unresolved delivery needs artifact/session inspection and lifecycle recovery, not a generic reinstall. Windows checks Task Scheduler, private state and coordinator identity; macOS checks launchd/screen readiness. Repair commands follow the selected platform and queue. The setup repair uses --keep-skill to retain an installed skill while installing one when missing. It can update the LTC coordinator configuration; inspect existing service customizations before doing so. Never replace a missing binding with an invented session or --last. For done, repair adds setup --callback-only: externally owned work needs the callback coordinator, not a local business-task execution backend.

Check work.state before retrying: task_persisted or callback_queued means repair the infrastructure around that existing ID, do not submit it again. For unknown, inspect that ID's task/queue records before deciding whether a retry is needed. For not_submitted, retry the original LTC invocation only after the prerequisites pass. A done invocation reports work already performed; repair or retry its callback without rerunning that work.

Use `ltc do

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars0
CategoryDevelopment
Updated13d ago
Forks0

Trust signals

80/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

1 medium1 low
long-task-callback — Claude Code Skill: Install & Safety Check | SkillAgent