@psnext/slingcli 3.0.20260827-1 → 3.1.20260904-1

package/node_modules/zod/v4/mini/schemas.d.ts

@@ -1,4 +1,5 @@
 import * as core from "../core/index.js";
+import type { $ZodBigIntFormats } from "../core/index.js";
 import * as util from "../core/util.js";
 type SomeType = core.SomeType;
 export interface ZodMiniType<out Output = unknown, out Input = unknown, out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> extends core.$ZodType<Output, Input, Internals> {
@@ -15,7 +16,7 @@ export interface ZodMiniType<out Output = unknown, out Input = unknown, out Inte
     safeParse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): util.SafeParseResult<core.output<this>>;
     parseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<core.output<this>>;
     safeParseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<util.SafeParseResult<core.output<this>>>;
-    apply<T>(fn: (schema: this) => T): T;
+    apply<T, TArgs extends unknown[] = []>(fn: (schema: this, ...args: TArgs) => T, ...args: TArgs): T;
 }
 interface _ZodMiniType<out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals> extends ZodMiniType<any, any, Internals> {
 }
@@ -127,6 +128,10 @@ export interface ZodMiniE164 extends _ZodMiniString<core.$ZodE164Internals> {
 }
 export declare const ZodMiniE164: core.$constructor<ZodMiniE164>;
 export declare function e164(params?: string | core.$ZodE164Params): ZodMiniE164;
+export interface ZodMiniCreditCard extends _ZodMiniString<core.$ZodCreditCardInternals> {
+}
+export declare const ZodMiniCreditCard: core.$constructor<ZodMiniCreditCard>;
+export declare function creditCard(params?: string | core.$ZodCreditCardParams): ZodMiniCreditCard;
 export interface ZodMiniJWT extends _ZodMiniString<core.$ZodJWTInternals> {
 }
 export declare const ZodMiniJWT: core.$constructor<ZodMiniJWT>;
@@ -148,14 +153,24 @@ export interface ZodMiniNumber<Input = unknown> extends _ZodMiniNumber<core.$Zod
 }
 export declare const ZodMiniNumber: core.$constructor<ZodMiniNumber>;
 export declare function number(params?: string | core.$ZodNumberParams): ZodMiniNumber<number>;
-export interface ZodMiniNumberFormat extends _ZodMiniNumber<core.$ZodNumberFormatInternals>, core.$ZodNumberFormat {
+export interface ZodMiniNumberFormat<Format extends core.$ZodNumberFormats = core.$ZodNumberFormats> extends _ZodMiniNumber<core.$ZodNumberFormatInternals<Format>>, core.$ZodNumberFormat<Format> {
 }
 export declare const ZodMiniNumberFormat: core.$constructor<ZodMiniNumberFormat>;
-export declare function int(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
-export declare function float32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
-export declare function float64(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
-export declare function int32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
-export declare function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
+export interface ZodMiniInt extends ZodMiniNumberFormat<"safeint"> {
+}
+export declare function int(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniInt;
+export interface ZodMiniFloat32 extends ZodMiniNumberFormat<"float32"> {
+}
+export declare function float32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniFloat32;
+export interface ZodMiniFloat64 extends ZodMiniNumberFormat<"float64"> {
+}
+export declare function float64(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniFloat64;
+export interface ZodMiniInt32 extends ZodMiniNumberFormat<"int32"> {
+}
+export declare function int32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniInt32;
+export interface ZodMiniUInt32 extends ZodMiniNumberFormat<"uint32"> {
+}
+export declare function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniUInt32;
 export interface ZodMiniBoolean<T = unknown> extends _ZodMiniType<core.$ZodBooleanInternals<T>> {
 }
 export declare const ZodMiniBoolean: core.$constructor<ZodMiniBoolean>;
@@ -164,11 +179,15 @@ export interface ZodMiniBigInt<T = unknown> extends _ZodMiniType<core.$ZodBigInt
 }
 export declare const ZodMiniBigInt: core.$constructor<ZodMiniBigInt>;
 export declare function bigint(params?: string | core.$ZodBigIntParams): ZodMiniBigInt<bigint>;
-export interface ZodMiniBigIntFormat extends _ZodMiniType<core.$ZodBigIntFormatInternals> {
+export interface ZodMiniBigIntFormat<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends _ZodMiniType<core.$ZodBigIntFormatInternals<Format>> {
 }
 export declare const ZodMiniBigIntFormat: core.$constructor<ZodMiniBigIntFormat>;
-export declare function int64(params?: string | core.$ZodBigIntFormatParams): ZodMiniBigIntFormat;
-export declare function uint64(params?: string | core.$ZodBigIntFormatParams): ZodMiniBigIntFormat;
+export interface ZodMiniInt64 extends ZodMiniBigIntFormat<"int64"> {
+}
+export declare function int64(params?: string | core.$ZodBigIntFormatParams): ZodMiniInt64;
+export interface ZodMiniUInt64 extends ZodMiniBigIntFormat<"uint64"> {
+}
+export declare function uint64(params?: string | core.$ZodBigIntFormatParams): ZodMiniUInt64;
 export interface ZodMiniSymbol extends _ZodMiniType<core.$ZodSymbolInternals> {
 }
 export declare const ZodMiniSymbol: core.$constructor<ZodMiniSymbol>;
@@ -223,8 +242,10 @@ export type SafeExtendShape<Base extends core.$ZodShape, Ext extends core.$ZodLo
     [K in keyof Ext]: K extends keyof Base ? core.output<Ext[K]> extends core.output<Base[K]> ? core.input<Ext[K]> extends core.input<Base[K]> ? Ext[K] : never : never : Ext[K];
 };
 export declare function safeExtend<T extends ZodMiniObject, U extends core.$ZodLooseShape>(schema: T, shape: SafeExtendShape<T["shape"], U>): ZodMiniObject<util.Extend<T["shape"], util.Writeable<U>>, T["_zod"]["config"]>;
-/** @deprecated Identical to `z.extend(A, B)` */
-export declare function merge<T extends ZodMiniObject, U extends ZodMiniObject>(a: T, b: U): ZodMiniObject<util.Extend<T["shape"], U["shape"]>, T["_zod"]["config"]>;
+/**
+ * @deprecated Use [`z.extend(A, B.shape)`](https://zod.dev/api?id=extend) instead.
+ */
+export declare function merge<T extends ZodMiniObject, U extends ZodMiniObject>(a: T, b: U): ZodMiniObject<util.Extend<T["shape"], U["shape"]>, U["_zod"]["config"]>;
 export declare function pick<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(schema: T, mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>): ZodMiniObject<util.Flatten<Pick<T["shape"], keyof T["shape"] & keyof M>>, T["_zod"]["config"]>;
 export declare function omit<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(schema: T, mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>): ZodMiniObject<util.Flatten<Omit<T["shape"], keyof M>>, T["_zod"]["config"]>;
 export declare function partial<T extends ZodMiniObject>(schema: T): ZodMiniObject<{
@@ -233,6 +254,15 @@ export declare function partial<T extends ZodMiniObject>(schema: T): ZodMiniObje
 export declare function partial<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(schema: T, mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>): ZodMiniObject<{
     -readonly [k in keyof T["shape"]]: k extends keyof M ? ZodMiniOptional<T["shape"][k]> : T["shape"][k];
 }, T["_zod"]["config"]>;
+export declare function partial<T extends util.TupleItems, Rest extends SomeType | null>(schema: ZodMiniTuple<T, Rest>): ZodMiniTuple<{
+    -readonly [k in keyof T]: ZodMiniOptional<T[k]>;
+}, Rest>;
+export declare function exactPartial<T extends ZodMiniObject>(schema: T): ZodMiniObject<{
+    -readonly [k in keyof T["shape"]]: ZodMiniExactOptional<T["shape"][k]>;
+}, T["_zod"]["config"]>;
+export declare function exactPartial<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(schema: T, mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>): ZodMiniObject<{
+    -readonly [k in keyof T["shape"]]: k extends keyof M ? ZodMiniExactOptional<T["shape"][k]> : T["shape"][k];
+}, T["_zod"]["config"]>;
 export type RequiredInterfaceShape<Shape extends core.$ZodLooseShape, Keys extends PropertyKey = keyof Shape> = util.Identity<{
     [k in keyof Shape as k extends Keys ? k : never]: ZodMiniNonOptional<Shape[k]>;
 } & {
@@ -260,7 +290,7 @@ export interface ZodMiniDiscriminatedUnion<Options extends readonly SomeType[] =
     _zod: core.$ZodDiscriminatedUnionInternals<Options, Disc>;
 }
 export declare const ZodMiniDiscriminatedUnion: core.$constructor<ZodMiniDiscriminatedUnion>;
-export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable<Disc>, ...core.$ZodTypeDiscriminable<Disc>[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodMiniDiscriminatedUnion<Types, Disc>;
+export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodMiniDiscriminatedUnion<Types, Disc>;
 export interface ZodMiniIntersection<A extends SomeType = core.$ZodType, B extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodIntersectionInternals<A, B>> {
 }
 export declare const ZodMiniIntersection: core.$constructor<ZodMiniIntersection>;

package/node_modules/zod/v4/mini/schemas.js

@@ -7,31 +7,49 @@ export const ZodMiniType = /*@__PURE__*/ core.$constructor("ZodMiniType", (inst,
     core.$ZodType.init(inst, def);
     inst.def = def;
     inst.type = def.type;
-    inst.parse = (data, params) => parse.parse(inst, data, params, { callee: inst.parse });
-    inst.safeParse = (data, params) => parse.safeParse(inst, data, params);
-    inst.parseAsync = async (data, params) => parse.parseAsync(inst, data, params, { callee: inst.parseAsync });
-    inst.safeParseAsync = async (data, params) => parse.safeParseAsync(inst, data, params);
-    inst.check = (...checks) => {
-        return inst.clone({
+}, {
+    // `with` is an alias for `check`: the same function object, not a wrapper.
+    get with() {
+        return this.check;
+    },
+    set with(value) {
+        util.own(this, "with", value);
+    },
+    parse(data, params) {
+        return parse.parse(this, data, params, { callee: this.parse });
+    },
+    parseAsync(data, params) {
+        return parse.parseAsync(this, data, params, { callee: this.parseAsync });
+    },
+    safeParse(data, params) {
+        return parse.safeParse(this, data, params);
+    },
+    safeParseAsync(data, params) {
+        return parse.safeParseAsync(this, data, params);
+    },
+    check(...checks) {
+        const def = this.def;
+        return this.clone({
             ...def,
             checks: [
                 ...(def.checks ?? []),
-                ...checks.map((ch) => typeof ch === "function"
-                    ? {
-                        _zod: { check: ch, def: { check: "custom" }, onattach: [] },
-                    }
-                    : ch),
+                ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch),
             ],
         }, { parent: true });
-    };
-    inst.with = inst.check;
-    inst.clone = (_def, params) => core.clone(inst, _def, params);
-    inst.brand = () => inst;
-    inst.register = ((reg, meta) => {
-        reg.add(inst, meta);
-        return inst;
-    });
-    inst.apply = (fn) => fn(inst);
+    },
+    clone(_def, params) {
+        return core.clone(this, _def, params);
+    },
+    brand() {
+        return this;
+    },
+    register(reg, meta) {
+        reg.add(this, meta);
+        return this;
+    },
+    apply(fn, ...args) {
+        return args.length === 0 ? fn(this) : fn(this, ...args);
+    },
 });
 export const ZodMiniString = /*@__PURE__*/ core.$constructor("ZodMiniString", (inst, def) => {
     core.$ZodString.init(inst, def);
@@ -231,6 +249,14 @@ export const ZodMiniE164 = /*@__PURE__*/ core.$constructor("ZodMiniE164", (inst,
 export function e164(params) {
     return core._e164(ZodMiniE164, params);
 }
+export const ZodMiniCreditCard = /*@__PURE__*/ core.$constructor("ZodMiniCreditCard", (inst, def) => {
+    core.$ZodCreditCard.init(inst, def);
+    ZodMiniStringFormat.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+export function creditCard(params) {
+    return core._creditCard(ZodMiniCreditCard, params);
+}
 export const ZodMiniJWT = /*@__PURE__*/ core.$constructor("ZodMiniJWT", (inst, def) => {
     core.$ZodJWT.init(inst, def);
     ZodMiniStringFormat.init(inst, def);
@@ -277,28 +303,18 @@ export const ZodMiniNumberFormat = /*@__PURE__*/ core.$constructor("ZodMiniNumbe
     core.$ZodNumberFormat.init(inst, def);
     ZodMiniNumber.init(inst, def);
 });
-// int
-// @__NO_SIDE_EFFECTS__
 export function int(params) {
     return core._int(ZodMiniNumberFormat, params);
 }
-// float32
-// @__NO_SIDE_EFFECTS__
 export function float32(params) {
     return core._float32(ZodMiniNumberFormat, params);
 }
-// float64
-// @__NO_SIDE_EFFECTS__
 export function float64(params) {
     return core._float64(ZodMiniNumberFormat, params);
 }
-// int32
-// @__NO_SIDE_EFFECTS__
 export function int32(params) {
     return core._int32(ZodMiniNumberFormat, params);
 }
-// uint32
-// @__NO_SIDE_EFFECTS__
 export function uint32(params) {
     return core._uint32(ZodMiniNumberFormat, params);
 }
@@ -322,13 +338,9 @@ export const ZodMiniBigIntFormat = /*@__PURE__*/ core.$constructor("ZodMiniBigIn
     core.$ZodBigIntFormat.init(inst, def);
     ZodMiniBigInt.init(inst, def);
 });
-// int64
-// @__NO_SIDE_EFFECTS__
 export function int64(params) {
     return core._int64(ZodMiniBigIntFormat, params);
 }
-// uint64
-// @__NO_SIDE_EFFECTS__
 export function uint64(params) {
     return core._uint64(ZodMiniBigIntFormat, params);
 }
@@ -420,7 +432,7 @@ export function keyof(schema) {
 export const ZodMiniObject = /*@__PURE__*/ core.$constructor("ZodMiniObject", (inst, def) => {
     core.$ZodObject.init(inst, def);
     ZodMiniType.init(inst, def);
-    util.defineLazy(inst, "shape", () => def.shape);
+    util.installLazyProp(inst, "shape", (self) => self._zod.def.shape, false);
 });
 // @__NO_SIDE_EFFECTS__
 export function object(shape, params) {
@@ -460,9 +472,12 @@ export function extend(schema, shape) {
 export function safeExtend(schema, shape) {
     return util.safeExtend(schema, shape);
 }
+/**
+ * @deprecated Use [`z.extend(A, B.shape)`](https://zod.dev/api?id=extend) instead.
+ */
 // @__NO_SIDE_EFFECTS__
-export function merge(schema, shape) {
-    return util.extend(schema, shape);
+export function merge(a, b) {
+    return util.merge(a, b);
 }
 // @__NO_SIDE_EFFECTS__
 export function pick(schema, mask) {
@@ -475,7 +490,20 @@ export function omit(schema, mask) {
 }
 // @__NO_SIDE_EFFECTS__
 export function partial(schema, mask) {
-    return util.partial(ZodMiniOptional, schema, mask);
+    const def = schema._zod.def;
+    if (def.type !== "tuple")
+        return util.partial(ZodMiniOptional, schema, mask);
+    // a refinement was authored against the full arity; partialing would run it on a shorter array
+    if (def.checks?.length)
+        throw new Error(".partial() cannot be used on tuple schemas containing refinements");
+    return util.clone(schema, {
+        ...def,
+        items: def.items.map((item) => new ZodMiniOptional({ type: "optional", innerType: item })),
+    });
+}
+// @__NO_SIDE_EFFECTS__
+export function exactPartial(schema, mask) {
+    return util.partial(ZodMiniExactOptional, schema, mask, "exactPartial");
 }
 // @__NO_SIDE_EFFECTS__
 export function required(schema, mask) {
@@ -520,7 +548,7 @@ export const ZodMiniDiscriminatedUnion = /*@__PURE__*/ core.$constructor("ZodMin
 export function discriminatedUnion(discriminator, options, params) {
     return new ZodMiniDiscriminatedUnion({
         type: "union",
-        options,
+        options: options,
         discriminator,
         ...util.normalizeParams(params),
     });
@@ -577,13 +605,12 @@ export function record(keyType, valueType, params) {
 }
 // @__NO_SIDE_EFFECTS__
 export function partialRecord(keyType, valueType, params) {
-    const k = core.clone(keyType);
-    k._zod.values = undefined;
     return new ZodMiniRecord({
         type: "record",
-        keyType: k,
+        keyType,
         valueType: valueType,
         ...util.normalizeParams(params),
+        partial: true,
     });
 }
 export function looseRecord(keyType, valueType, params) {
@@ -779,7 +806,7 @@ function _catch(innerType, catchValue) {
     return new ZodMiniCatch({
         type: "catch",
         innerType: innerType,
-        catchValue: (typeof catchValue === "function" ? catchValue : () => catchValue),
+        catchValue: (typeof catchValue === "function" ? catchValue : core.util.constantCatch(catchValue)),
     });
 }
 export { _catch as catch };
@@ -891,8 +918,7 @@ export function check(fn, params) {
     ch._zod.check = fn;
     return ch;
 }
-// ZodCustom
-// custom schema
+// ZodCustom custom schema
 // @__NO_SIDE_EFFECTS__
 export function custom(fn, _params) {
     return core._custom(ZodMiniCustom, fn ?? (() => true), _params);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@psnext/slingcli",
-  "version": "3.0.20260827-1",
+  "version": "3.1.20260904-1",
   "description": "Connects Sling CLI to Publicis Sapient Slingshot enterprise LLM gateway. Bundles the pi coding-agent runtime.",
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
   "files": [
     "bin",
     "slingshot",
+    "skills",
     "sling-default-packages.json",
     "README.md",
     "LICENSE"
@@ -29,7 +30,7 @@
     "type": "git",
     "url": "git+https://pscode.lioncloud.net/psaiproducts/slingcli.git"
   },
-  "slingVersion": "3.0.20260827-1",
+  "slingVersion": "3.1.20260904-1",
   "dependencies": {
     "@earendil-works/pi-tui": "file:../.sling-pack/earendil-works-pi-tui-0.84.3.tgz",
     "@earendil-works/pi-ai": "file:../.sling-pack/earendil-works-pi-ai-0.84.3.tgz",

package/skills/context-management/SKILL.md

@@ -0,0 +1,258 @@
+---
+name: context-management
+description: Strategies for efficient context management using context_log, context_tag, and context_checkout. Learn when to tag, how to visualize the graph, and safe ways to squash history. Use for complex refactoring, debugging, and long conversations.
+---
+
+# Context Management
+
+**CRITICAL: THIS SKILL MANAGES YOUR MEMORY. WITHOUT IT, YOU WILL FORGET.**
+
+Your context window is limited. As conversations grow, "pollution" (noise, failed attempts) degrades your reasoning.
+
+**YOU MUST PROACTIVELY MANAGE YOUR HISTORY.**
+Do not wait for the user to tell you.
+
+## The Core Philosophy: Build, Perceive, Navigate
+
+```
+Context Window = RAM (Expensive, volatile, limited)
+Context Graph  = Disk (Cheap, persistent, unlimited)
+
+→ Move finished tasks from RAM to the Graph.
+```
+
+Manage your context window like a Git repository. You are the maintainer.
+
+1.  **BUILD the Skeleton (`context_tag`)**:
+    *   Raw conversation is a flat list. **Tags create structure.**
+    *   Without tags, `context_log` is just a list of IDs. With tags, it is a **Map**.
+2.  **PERCEIVE the State (`context_log`)**:
+    *   Check the HUD: Is "Segment Size" too big? You are drifting.
+    *   Check the Graph: Where are you? Are you in a deep branch?
+3.  **NAVIGATE & MERGE (`context_checkout`)**:
+    *   **Squash:** Convert a messy "feature branch" (thinking process) into a single "merge commit" (summary).
+    *   **Jump:** Move between tasks or retry paths without carrying baggage.
+
+## Quick Start: The Loop
+
+Follow this cycle for every major task:
+
+1.  **CHECK:** Verify state.
+    `context_log`
+2.  **START:** Tag the beginning with a semantic name.
+    `context_tag({ name: "<task-slug>-start" })`  // e.g., `auth-login-start`
+3.  **WORK:** Execute steps.
+4.  **MILESTONE:** Tag intermediate stable states.
+    `context_tag({ name: "<task-slug>-plan" })`  // e.g., `auth-login-plan`
+5.  **SQUASH (Autonomous):** If history becomes noisy or low-density, **Squash with Backup**.
+    *   *Action:* `context_checkout({ target: "<task-slug>-start", message: "...", backupTag: "<task-slug>-raw-history" })`
+    *   *Action (Optional):* `context_tag({ name: "<task-slug>-done" })`
+    *   *Safety:* If you need the details later, checkout the backup tag.
+
+## Tool Reference
+
+| Tool | Analog | Purpose | When to Use |
+| :--- | :--- | :--- | :--- |
+| `context_tag` | `git tag` | Bookmark a stable state. | Before risky changes. Before starting a new task. |
+| `context_log` | `git log` | See where you are. | When you feel lost. To find IDs for checkout. |
+| `context_checkout`| `git reset --soft` | **Time Travel / Squash.** | To undo mistakes. To compress history. |
+
+## Critical Rules
+
+### Tag Wisely (Build The Skeleton)
+
+Tags are the "Table of Contents". Name them so you can understand the history at a glance.
+
+**Naming Formula:** `<task-slug>-<phase>`
+
+*   **task-slug**: Short, kebab-case identifier for the task (e.g., `auth-login`, `db-migration`)
+*   **phase**: The stage of work (`start`, `plan`, `impl`, `done`, `fail`, `backup`)
+
+| Bad (Generic) | Good (Semantic) | Why |
+| :--- | :--- | :--- |
+| `task-start` | `auth-oauth-start` | Describes WHAT task |
+| `pre-research` | `error-log-analysis-start` | Future-you knows the topic |
+| `phase-1-done` | `db-schema-plan-done` | Know which phase of which task |
+| `debug-retry` | `null-pointer-fix-retry` | What bug? |
+
+**Tag Categories:**
+
+| Category | Pattern | Examples |
+| :--- | :--- | :--- |
+| **Start** | `<task>-start` | `auth-jwt-start`, `docker-setup-start` |
+| **Plan** | `<task>-plan` | `api-v2-plan`, `migration-plan` |
+| **Milestone** | `<task>-<milestone>` | `auth-jwt-impl-done`, `tests-passed` |
+| **Backup** | `<task>-raw-history` | `auth-jwt-raw-history` |
+| **Failure** | `<task>-fail-<reason>` | `auth-jwt-fail-timeout` |
+
+**How to generate:** Ask yourself "What is the task?" → Extract 1-3 keywords (e.g., "fix login timeout" → `login-timeout-fix-start`)
+
+### Squash Noise, Keep Signal, Focus on Goal (Context Hygiene)
+Think of your conversation as a "Feature Branch" full of messy thoughts.
+**You must distinguish Signal from Noise.**
+
+*   **Signal (High Value):** Design decisions, user constraints, final working code. -> **KEEP.**
+*   **Noise (Low Value):** Failed attempts, long tool outputs, "thinking" steps. -> **SQUASH.**
+*   **Focus on Goal:** Ask yourself: "Does this message help me achieve the current goal?" -> **KEEP.**
+
+**When to Squash:**
+1.  **Task Done:** Convert the messy process into one clean summary.
+2.  **Low Density:** You read 2000 lines but only found 1 error.
+
+**Safety:** Squashing is **LOSSLESS**.
+By using `backupTag`, you save the "Messy Branch" forever. You can always checkout the backup tag if the summary isn't enough.
+*   **Main Trunk:** Jump back to the summary.
+*   **Backup Tag:** Jump back to the raw details.
+
+### Fail Fast, Revert Faster
+If you fail 3 times:
+1.  **STOP.** Don't try a 4th time.
+2.  `context_checkout` back to the last safe tag.
+3.  Summarize the failure in the checkout message ("Tried X, failed because Y").
+4.  Try a new approach from the clean state.
+
+### After Checkout: Execute Next Step
+
+When `context_checkout` completes and injects a summary, you are in a **new context**.
+
+1. **READ** the injected summary carefully
+2. **EXECUTE** the `Next Step` from the summary - this is your new task.
+
+## Decision Matrix: When to Act
+
+| Situation | Action | Reason |
+| :--- | :--- | :--- |
+| **Starting Task** | `context_tag({ name: "<task-slug>-start" })` | Create a rollback point. |
+| **Research / Logs** | `context_checkout` (Squash) | **Process is Noise.** Read 2000 lines -> Keep result. |
+| **Messy Debugging** | **Squash w/ Backup** | **Cleanup.** The error logs are noise once fixed. |
+| **Task Done (Candidate)**| **Squash w/ Backup** | **Assume Success.** Summary is usually enough. Backup exists if not. |
+| **Goal Shift** | `context_checkout` (Squash) | Old context is irrelevant. |
+| **Drift (some steps w/o tag)** | **Tag (Milestone)** | Maintain the skeleton. Don't fly blind. |
+
+## The "Context Health" Check
+
+If you cannot answer these, run `context_log`:
+
+| Question | Answer Source |
+| :--- | :--- |
+| **Where is the skeleton?** | The sequence of `tag`s in the log. |
+| **Is this history useful?** | If "No" -> **SQUASH IT.** |
+| **Am I in a loop?** | Repeated entries in the graph. |
+
+## Good Checkout Messages
+
+The `message` is your lifeline to your past self.
+A good message preserves critical context that would otherwise be lost.
+
+Structure: `[Key Finding/Status] + [Reason] + [Important Changes] + [Next Step]`
+
+*   **Key Finding/Status**: What did you discover or complete? Include specific numbers, errors, or outcomes.
+*   **Reason**: Why are you branching/moving? (e.g., "Task complete", "Approach failed", "Need raw logs")
+*   **Important Changes**: What files or logic have been modified? (This checkout only resets *conversation history*, NOT disk files, so you must remember what changed.)
+*   **Next Step**: What should you do immediately after this squash? Be specific. (e.g., "Wait for user feedback", "Implement the recommended fix", "Revert file X and try approach Y")
+
+Examples:
+
+*   *Good (Resetting after failure)*: "Recursive parser hit stack overflow at depth 8000. Switching to iterative. **Reason**: Stack limit reached. **Important Changes**: Modified `utils/recursion.ts`. **Next Step**: Inform user of the failure and propose iterative approach."
+*   *Good (Cleaning up)*: "Auth module complete: JWT + OAuth2 + RBAC. 23 tests passing. **Reason**: Task done, cleaning context. **Important Changes**: Created `auth/`, modified `routes.ts` and `middleware.ts`. **Next Step**: Report completion to user, ask if they want to review or test."
+*   *Bad*: "Switching context." (Too vague - you will forget why)
+*   *Bad*: "Done." (What is done? What should you do next?)
+
+## Anti-Patterns
+
+| Don't | Do Instead |
+| :--- | :--- |
+| **Blind Tagging** (Tagging without looking) | **Check** (`context_log`) to avoid duplicates or tagging noise. |
+| **Over-Tagging** (Tagging every step) | **Tag** only major phase changes (`start`, `milestone`). |
+| **Hoard** (Keep all history "just in case") | **Squash** low-density history (research, logs). |
+| **Panic** (Apologize repeatedly for errors) | **Revert** (`context_checkout`) to before the error. |
+| **Blind Checkout** (Guessing IDs) | **Look** (`context_log`) first to get valid IDs. |
+| **Vague Summaries** ("Done", "Fixed") | **Detailed Summaries** ("Found bug in line 40. Fixed with patch X.") |
+| **Generic Tag Names** (`task-start`, `phase-1`) | **Semantic Names** (`auth-jwt-start`, `db-schema-plan`) |
+| **Missing Next Step** in checkout message | **Always specify** what to do after squash (e.g., "Wait for user", "Implement fix X") |
+
+## Recipes (Copy-Paste)
+
+### 1. The "Miner" (Immediate Squash)
+**Goal:** Pure information gathering (Reading files, Searching web).
+**Why:** The *process* of searching is irrelevant. Only the *result* matters.
+
+**Example Task:** Analyzing error logs to find root cause of timeout
+
+```javascript
+// 1. Tag BEFORE starting the noisy work (use descriptive name)
+context_tag({ name: "timeout-analysis-start" });
+
+// ... (Read 5 log files, search 3 docs, find DB connection pool exhaustion) ...
+
+// 2. Squash IMMEDIATELY. Do not wait for user.
+context_checkout({
+  target: "timeout-analysis-start",
+  message: "Found DB connection pool exhaustion as root cause (pool size: 10, peak load: 1000 req/s). Recommended fix: increase to 50. **Reason**: Context cleanup after research. **Important Changes**: None (read-only). **Next Step**: Report findings to user and await approval to implement fix.",
+  backupTag: "timeout-analysis-raw-history" // Safety backup
+});
+context_tag({ name: "timeout-analysis-done" });
+```
+
+### 2. The "Candidate" (Wait for Confirmation)
+**Goal:** You finished a complex task.
+**Why:** The history is noisy. The result is clean.
+**Safety:** We create a backup tag automatically.
+
+**Example Task:** Implementing OAuth login flow
+
+```javascript
+// Squash to Summary (Optimistic Cleanup)
+context_checkout({
+  target: "oauth-impl-start", // Squash range: Start -> Now
+  message: "OAuth2 flow implemented with PKCE, Google + GitHub providers. All 12 tests passing. **Reason**: Task complete, cleaning up. **Important Changes**: Created `auth/oauth.ts`, modified `routes.ts`, `config.ts`. **Next Step**: Report completion to user, summarize what was implemented.",
+  backupTag: "oauth-impl-raw-history"
+});
+context_tag({ name: "oauth-impl-candidate" });
+```
+
+### 3. The "Undo" (Revert Squash)
+**Goal:** User asks about a detail you squashed away.
+**Action:** Jump back to the backup tag.
+
+**Example Task:** Reviewing OAuth implementation details
+
+```javascript
+// Jump back to the raw history
+context_checkout({
+  target: "oauth-impl-raw-history",
+  message: "Reviewing token refresh logic - user reports 401 after 15 min idle. Suspect refresh token not firing. **Reason**: Need raw logs to trace the bug. **Important Changes**: None. **Next Step**: Re-read token refresh implementation and identify the bug."
+});
+context_tag({ name: "oauth-review-start" });
+```
+
+### 4. Branching (Alternative Approach)
+**Scenario:** Method A failed (and was squashed). You want to try Method B from the clean state.
+**Action:** Checkout the start point.
+
+**Example Task:** Fixing memory leak - trying different approaches
+
+```javascript
+// Method A (weak references) failed, trying Method B (object pooling)
+context_checkout({
+  target: "memory-leak-fix-start", 
+  message: "WeakRef approach failed: objects GC'd within 30s (expected: 5min). Cache hit rate dropped from 95% to 12%. **Reason**: Switching to object pooling approach. **Important Changes**: `CacheManager.ts` modified (will revert). **Next Step**: Revert `CacheManager.ts` changes and implement object pooling strategy."
+});
+context_tag({ name: "memory-leak-pool-approach-start" });
+```
+
+### 5. The "Undo" (Failed Attempt)
+You tried to fix a bug but broke everything.
+**Goal:** Clean up a failed path.
+
+**Example Task:** Fixing race condition in async handler
+
+```javascript
+// Attempted mutex-based fix, but introduced deadlock
+context_checkout({
+  target: "race-condition-fix-start",
+  message: "Mutex caused deadlock: Thread A holds mutex, awaits callback; callback needs mutex held by B; B waits for A. Circular wait detected. **Reason**: Trying lock-free CAS approach next. **Important Changes**: `AsyncQueue.ts` lines 70-90 modified (backup saved). **Next Step**: Revert `AsyncQueue.ts` and implement lock-free compare-and-swap approach.",
+  backupTag: "race-condition-mutex-fail" // Save the failure for reference
+});
+context_tag({ name: "race-condition-lockfree-start" });
+```