Long Task Continuation logo

Long Task Continuation

CommunityPopular
GanyuanRan
long-task-continuation

Use when a task is multi-step, may span context resets or sessions, uses subagents, or risks losing state before completion.

Overview

PublisherGanyuanRan
RepositoryAegis
Skill namelong-task-continuation
Stars
1.2K
Forks
52
Bundled files
1
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 1 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by GanyuanRan on GitHub. Read the source before you install it.

Installation

Install the Long Task Continuation AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/GanyuanRan/Aegis.git /tmp/Aegis
mkdir -p .claude/skills
cp -r /tmp/Aegis/skills/long-task-continuation .claude/skills/long-task-continuation
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Long Task Continuation in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Long Task Continuation on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Long Task Continuation is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Long Task Continuation

Overview

Keep long work checkpointed, resumable, drift-aware, and evidence-gated. This protocol does not execute plans, dispatch subagents, run tests, or grant completion authority.

Authority Boundary

The Method Pack owns continuation discipline only. It does not own the parent plan, host retry/watchdog behavior, authoritative GateDecision, evidence sufficiency, requirement acceptance, or completion.

When To Use

Use this skill when the work has meaningful phases, may be compacted/resumed or handed off, uses subagents, or explicitly needs continuity and drift control. Architecture, contract, shared-workflow, and verification-gate changes also benefit from it. Do not force it onto a short answer or one-command check.

Choose exactly one state carrier:

  • use a durable work/ record for medium+ work that actually crosses sessions, needs handoff, or requires resumable state;
  • otherwise keep one inline checkpoint.

Multi-step, todo-driven, possible-compaction, and subagent use do not force durable records by themselves. Do not create both carriers or a record per slice.

Required Artifacts

A durable task has one process trail under docs/aegis/work/YYYY-MM-DD-<slug>/. It keeps logical intent/baseline state, the latest todo/checkpoint/resume state, terminal evidence/drift state, and a completion reflection when warranted. These are TaskIntentDraft, BaselineReadSetHint, BaselineUsageDraft, ImpactStatementDraft, TodoCheckpointDraft, ResumeStateHint, DriftCheckDraft, and EvidenceBundleDraft views—not authoritative runtime records or separate plan owners.

Read only the lifecycle-matched section of durable-work-guidance.md:

  • ## Required Artifact Layout and ## Create A Durable Work Record for a new durable work record;
  • ## Update A Slice when an existing helper-backed record needs sidecar updates;
  • ## Retry Convergence Detail for retry/attempt bookkeeping;
  • ## Pause, Handoff, And Completion Bundle when preparing a pause, handoff, or completion bundle; and
  • ## Expanded State Fields only when natural checkpoint prose is ambiguous.

The reference owns artifact layout and <aegis-workspace-helper> command detail; this file owns carrier selection, resume order, drift decisions, and stop conditions.

An Execution Readiness View may be kept in the intent or active checkpoint for medium/high, handoff-prone, long-running, subagent-driven, architecture, contract, compatibility, or retirement-sensitive work. It renders existing intent, scope, baseline, owner, test, review, and drift constraints; it is not a new JSON artifact or completion authority.

Planless Slice Lane:

  • When an existing parent plan/spec owns a bounded task, reuse it and the current checkpoint. For a no-parent direct bounded request with no new durable or unclear verification boundary, use an inline checkpoint.
  • State one compact Slice Card: Goal, Parent plan/spec (or none — direct bounded request), Files, Boundary, Verification, and Stop.
  • The slice goal closes only that slice. Final completion returns to the parent or direct bounded request through verification-before-completion.
  • Do not create a plan/spec merely to give a micro-slice a parent, and do not create per-slice plans/specs or work records.
  • Escalate when a new owner, contract, schema, public API, architecture, migration, persistence, security/permission, distribution/release surface, unclear verification boundary, or mismatch with parent scope or acceptance appears.

When durable architecture decisions are in scope, these work records are the preferred ADR Auto Backfill source. Preserve decision signals, source refs, alternatives, compatibility, retirement, drift, and baseline-sync questions.

Start Protocol

Before execution:

  1. Capture requested outcome, scope, non-goals, risks, parent plan/goal, success evidence, and stop states (done | blocked | needs-verification | scope-exceeded).
  2. Identify required baseline refs and record acknowledged, cited, and missing refs. Missing authority pauses in needs-baseline-readback.
  3. Choose inline or durable state once, then record the todo map, active slice, completed slices/evidence, blockers, next step, and current branch/HEAD.
  4. When an Execution Readiness View exists, retain its intent lock, scope fence, baseline lock, compatibility/retirement boundary, tests, reviews, evidence, and rewind rules.
  5. For a new helper-backed record, use durable-work-guidance.md to create and structurally check it before implementation.

Retry Convergence Protocol

A failed verification is another attempt in the current slice, not a new slice. Keep failed-attempt telemetry out of terminal evidence and normal commits. Only evidence-finalized, blocked, or abandoned is terminal. When retry state reaches process-artifact-pressure, stop auto-retry and route to systematic-debugging or verification-before-completion. Load the durable reference only when the attempt/evidence commands or sidecar rules are needed.

Per-Slice Protocol

Before each slice, state the current goal/todo, intended edits, explicit non-edits, verification, and readiness alignment. A bounded parent-plan or no-parent slice uses the compact Slice Card rather than a new plan/spec.

After each slice, update completed todos, evidence refs, newly used baseline refs, blockers, next step, and drift decision. When an active helper-backed work record exists, read durable-work-guidance.md and update that same record; never create another workstream for bookkeeping.

When patch-shape/ripple triage, an H-class finding, or a bounded compatibility mitigation fired, a locally green result does not clear the direction. Retain PatchShape, CanonicalOwner, UpwardDrillSignal, latest outcome, and one bounded evidence ref; do not copy raw logs or full diffs. If no fresh evidence exists, the state is needs-verification or partial.

Resume Protocol

Resume in this order:

  1. Read original intent, parent plan/goal, latest checkpoint and resume hint.
  2. Re-read required baseline refs and relevant active CONTEXT.md language.
  3. Read the Execution Readiness View when present.
  4. Compare checkpoint branch/HEAD, completed commits, evidence refs, and claims with the current worktree.
  5. Compare the active slice against intent lock, scope fence, baseline lock, compatibility/retirement boundary, tests, reviews, and non-goals.
  6. Re-run the drift decision, then name the next smallest authorized action.

Any disagreement among plan, checkpoint, baseline, context, readiness view, or worktree pauses execution. A semantic conflict routes to establishing-project-context; an unplanned repair re-reads the retained invariant, owner seam, patch shape, and causal topology, then route comparison to systematic-debugging. A new carrier name alone does not prove a new direction. Never resume from memory alone.

Drift Check

Check original intent and stop condition, parent scope/acceptance, compatibility, new owners/fallbacks/adapters/branches, retirement, evidence freshness, and any readiness locks. Allowed decisions are continue, pause-for-user, needs-baseline-readback, needs-verification, and blocked.

Never emit gate-passed, completion-granted, or authoritatively-safe.

Completion Candidate Protocol

Before a completion claim:

  1. Use aegis:verification-before-completion.
  2. Confirm every todo has status, blockers are resolved/externalized, evidence covers acceptance, and drift has no blocking state.
  3. If a durable record exists, load durable-work-guidance.md for the completion bundle and structural workspace check.
  4. For durable architecture work, pass the work record, proof bundle and ADR signals to verification for ADR Backfill Check.

Generated packs are future-runtime inputs only. Method Pack output remains verified evidence and advisory judgment, not authoritative completion.

Minimal Reporting Shape

Report naturally and omit empty structures. Keep these semantic slots visible: Aegis Visibility; current todo/active/completed/next; baseline usage decision; readiness state when present; fresh evidence; retry/convergence state when relevant; drift decision; risk/unknown; and the next smallest safe action.

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Long Task Continuation AI skill do?

Use when a task is multi-step, may span context resets or sessions, uses subagents, or risks losing state before completion.

Why use Long Task Continuation on TypingMind?

Because you install it once and use it with any model. Long Task Continuation is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Long Task Continuation in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/GanyuanRan/Aegis/tree/main/skills/long-task-continuation. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Long Task Continuation?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Long Task Continuation?

As many as you like. As long as a model supports skills, you can use Long Task Continuation with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Long Task Continuation AI skill free?

Yes. It is published on GitHub by GanyuanRan under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇