@gajae-code/coding-agent 0.12.5 → 0.12.7

package/dist/types/sdk/broker/broker.d.ts

@@ -23,6 +23,7 @@ export type BrokerErrorCode = "idempotency_conflict" | "terminal_uncertain" | "b
 export type BrokerCleanupIdentity = {
     dev: string;
     ino: string;
+    nlink?: string;
     size: number;
     mtimeNs: string;
     sha256: string;
@@ -51,6 +52,7 @@ export type BrokerArtifactTree = {
 };
 export type BrokerCleanupEvidence = {
     phase: "artifacts" | "transcript" | "metadata" | "lifecycle";
+    cleanupReceiptVersion?: 1;
     /** Ledger-bound deletion target; never reconstructed from a retry request. */
     sessionsRoot?: string;
     transcriptPath?: string;
@@ -59,6 +61,10 @@ export type BrokerCleanupEvidence = {
     sessionId?: string;
     artifactsIdentity?: BrokerCleanupIdentity;
     transcriptIdentity?: BrokerCleanupIdentity;
+    transcriptParentIdentity?: {
+        dev: string;
+        ino: string;
+    };
     /** Identity-bound lifecycle metadata marker retained when exact cleanup is deferred. */
     metadataIdentity?: BrokerCleanupIdentity;
     metadataPath?: string;
@@ -71,9 +77,17 @@ export type BrokerCleanupEvidence = {
     /** Append-only terminal proof for lifecycle metadata cleanup. */
     metadataCompleted?: true;
     detachedArtifactsPath?: string;
+    retainedArtifactsSuccessorPath?: string;
+    retainedArtifactsPlaceholderPath?: string;
+    retainedArtifactsUnknownPath?: string;
+    retainedArtifactsSideAuthority?: "none" | "retained";
     detachedTranscriptPath?: string;
+    retainedTranscriptSuccessorPath?: string;
+    retainedTranscriptPlaceholderPath?: string;
+    retainedTranscriptUnknownPath?: string;
     /** Durable proof that artifact cleanup completed before transcript mutation. */
     artifactsRemoved?: boolean;
+    artifactsAbsentAtAuthorization?: true;
     /** Preauthorized no-replace artifact quarantine path persisted before detach. */
     plannedArtifactsPath?: string;
     /** Identity-bound artifact tree authority persisted before broker detach and replayed exactly. */
@@ -82,6 +96,10 @@ export type BrokerCleanupEvidence = {
     plannedTranscriptPath?: string;
     /** Fully identity-bound startup-failure cleanup plan, persisted before any detach. */
     lifecycleFiles?: BrokerLifecycleCleanupFile[];
+    lifecycleParentIdentity?: {
+        dev: string;
+        ino: string;
+    };
     /** Delete metadata receipts authorize only the canonical marker/ready sibling pair. */
     lifecycleDeleteMetadata?: true;
 };

package/dist/types/sdk/broker/lifecycle-ledger.d.ts

@@ -66,6 +66,11 @@ export interface LifecycleLedgerEntry {
     endpointGeneration?: number;
     responseDigest?: string;
     response?: unknown;
+    unresolvedCleanupResponse?: unknown;
+    unresolvedCleanupResponseDigest?: string;
+    uncertainCleanupSessionId?: string;
+    uncertainCleanupSessionIds?: string[];
+    uncertainCleanupAllSessions?: true;
     ts: number;
 }
 export type BeginResult = {
@@ -105,5 +110,13 @@ export declare class LifecycleLedger {
     begin(identity: string, requestHash: string): Promise<BeginResult>;
     transition(identity: string, state: LifecycleState, fields?: Omit<Partial<LifecycleLedgerEntry>, "identity" | "requestHash" | "state" | "ts">): Promise<LifecycleLedgerEntry>;
     assertSupportedStateVersions(): Promise<void>;
+    findCleanupPendingByDeleteTarget(target: {
+        sessionId: string;
+        sessionsRoot?: string;
+        transcriptPath: string;
+        cwd: string;
+    }, excludingIdentity: string): LifecycleLedgerEntry | undefined;
+    findCleanupPendingBySessionId(sessionId: string, excludingIdentity: string): LifecycleLedgerEntry | undefined;
+    hasUncertainCleanupForSession(sessionId: string, excludingIdentity: string): boolean;
     get(identity: string): LifecycleLedgerEntry | undefined;
 }

package/dist/types/sdk/broker/lifecycle.d.ts

@@ -92,6 +92,7 @@ export declare function readSessionLifecycleFailureForTest(root: string, id: str
     effectMarker: string;
     incarnation: string;
 }): Promise<SdkStartupFailure | undefined>;
+export declare function canonicalDeleteLocatorPath(pathname: string): string;
 export interface LifecycleExecutionOutcome {
     response: BrokerResponse;
     durableEffects?: LifecycleDurableEffectsReceipt;

package/dist/types/sdk/bus/chat-daemon-control.d.ts

@@ -20,9 +20,8 @@ export type ChatDaemonAction = "stop" | "reload";
  * applies the current notification configuration directly when starting chat
  * daemon transports. Generation 16 applies Telegram sound-policy configuration
  * through shared notification parsing. Generation 17 bound managed-session
- * replacement to exact native filesystem authority; generation 18 retires that
- * binding (revert of #3489, which stalled POSIX artifact cleanup) while keeping
- * the lifecycle contract moving strictly forward.
+ * replacement to exact native filesystem authority; generation 18 retired that
+ * binding, and generation 19 binds exact cleanup to parent/link-count authority.
  */
 export declare const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>>;
 export declare function chatDaemonGeneration(kind: ChatDaemonKind): number;

package/dist/types/sdk/bus/index.d.ts

@@ -17,6 +17,7 @@
  * Enable with Settings notifications config, `GJC_NOTIFICATIONS=1` (a token is
  * generated), or `GJC_NOTIFICATIONS_TOKEN`.
  */
+import { type RunSettlementProof } from "@gajae-code/agent-core";
 import type { Tool } from "@gajae-code/ai";
 import { NotificationServer } from "@gajae-code/natives";
 import { Settings } from "../../config/settings";
@@ -33,6 +34,9 @@ import { NotificationSessionController } from "./session-control";
 import { type EnsureDaemonResult, type RegisterNotificationRootResult } from "./telegram-daemon";
 export type { IdentityControlSuccessPathInput, IdentityControlTerminalPathInput, TerminalSendOutcome, } from "./control-drain-lease";
 export { isNativeControlDrainAvailable, runIdentityControlSuccessPath, runIdentityControlTerminalPath, } from "./control-drain-lease";
+export declare function formatPromptSettlementDiagnostic(proof: Extract<RunSettlementProof, {
+    status: "unfenced";
+}>, now?: number): string;
 /** Where a `session_create` should run. Discriminated by `kind`. */
 export type SessionCreateTarget = {
     kind: "existing_path";

package/dist/types/sdk/bus/telegram-daemon-contract.d.ts

@@ -47,9 +47,9 @@ export declare const NOTIFICATION_PROTOCOL_VERSION = 3;
  * user-created topic adoption (forum-topic folder picker). Generation 36 bound
  * managed-session replacement to exact native filesystem authority; generation
  * 37 retires that binding (revert of #3489, which stalled POSIX artifact
- * cleanup) while keeping the lifecycle contract moving strictly forward.
+ * cleanup); generation 38 binds exact cleanup to parent and link-count authority.
  */
-export declare const DAEMON_GENERATION = 37;
+export declare const DAEMON_GENERATION = 38;
 /**
  * Serving-compatibility boundary for daemon lifecycle requests. Epoch 1 covers
  * all builds published before this field existed; epoch 2 covered generation 29;

package/dist/types/sdk/bus/telegram-daemon.d.ts

@@ -61,11 +61,13 @@ export interface TelegramDaemonFs {
         size?: number;
         dev?: number;
         ino?: number;
+        /** Hard-link count; required to prove a staging temp has no second name. */
+        nlink?: number;
         ctimeMs?: number;
         isDirectory?: () => boolean;
     }>;
     readEndpointFile?(path: string): Promise<NotificationEndpointFile>;
-    exactUnlink?(path: string, identity: NotificationEndpointFileIdentity): Promise<NotificationExactUnlinkResult>;
+    exactUnlink?(path: string, identity: NotificationEndpointFileIdentity, quarantineName?: string): Promise<NotificationExactUnlinkResult>;
 }
 export interface SpawnResult {
     pid?: number;
@@ -281,11 +283,26 @@ export declare function withNotificationRootRegistryFence(input: {
  * (#2956). Nothing previously reaped these; they accumulate in the notifications
  * directory across ownership transitions.
  */
-export declare const NOTIFICATION_LEAK_ARTIFACT_PREFIXES: readonly [".gjc-delete-daemon-transition-", ".gjc-exact-unlink-placeholder-", ".gjc-delete-notification-endpoint-"];
+export declare const NOTIFICATION_LEAK_ARTIFACT_PREFIXES: readonly [".gjc-delete-daemon-transition-", ".gjc-exact-unlink-placeholder-", ".gjc-delete-notification-endpoint-", ".gjc-delete-notification-staging-temp-"];
 /** Grace window before a leak artifact is reaped (covers in-flight unlinks). */
 export declare const NOTIFICATION_LEAK_ARTIFACT_GRACE_MS: number;
 /** True when a path is permanently gone (not a transient I/O blip). */
 export declare function isPermanentMissingPathError(error: unknown): boolean;
+/** A publication staging claim recovered from an abandoned temp's name. */
+export interface NotificationStagingTempClaim {
+    /** Published sibling this temp was staged for. */
+    destination: string;
+    /** PID of the process that staged it. */
+    pid: number;
+    /** Wall-clock ms the publisher recorded when it staged the temp. */
+    stagedAtMs: number;
+}
+/**
+ * Recover the publication claim encoded in a staging temp's name, or
+ * `undefined` when `name` is not a staging temp or its PID/timestamp fields are
+ * not usable integers. An unparseable claim is never reaped.
+ */
+export declare function parseNotificationStagingTemp(name: string): NotificationStagingTempClaim | undefined;
 export declare function isNotificationLeakArtifactName(name: string): boolean;
 /**
  * Drop permanently missing scan roots from the durable registry under the roots
@@ -302,13 +319,16 @@ export declare function pruneMissingNotificationRoots(input: {
 }>;
 /**
  * Reap retained exact-unlink / ownership-transition quarantine files older than
- * the grace window from the notifications directory.
+ * the grace window from the notifications directory, plus publication staging
+ * temps whose publisher is provably dead.
  */
 export declare function reapStaleNotificationArtifacts(input: {
     settings: Settings;
     fs?: TelegramDaemonFs;
     now?: () => number;
     graceMs?: number;
+    /** Liveness seam used to prove a staging temp's publisher is dead. */
+    pidAlive?: (pid: number) => boolean;
 }): Promise<{
     removed: string[];
     skipped: number;
@@ -322,6 +342,8 @@ export declare function healTelegramDaemonNotificationState(input: {
     fs?: TelegramDaemonFs;
     now?: () => number;
     graceMs?: number;
+    /** Liveness seam used to prove a staging temp's publisher is dead. */
+    pidAlive?: (pid: number) => boolean;
 }): Promise<{
     prunedRoots: string[];
     removedArtifacts: string[];

package/dist/types/sdk/bus/topic-registry.d.ts

@@ -92,6 +92,17 @@ export interface TopicDeleteAuthoritySnapshot {
     /** Exact fenced record, retained to restore an in-memory tombstone after a failed clear publication. */
     record?: TopicRecord;
 }
+/**
+ * Proof that a definite delete was settled in memory and still owes its durable
+ * commit. Handed back only by a settlement that actually happened, so a refused
+ * settlement structurally cannot be followed by a rollback.
+ */
+export interface TopicSettledDelete {
+    sessionId: string;
+    topicId: string;
+    /** Authority epoch proven current when the record was removed. */
+    settledEpoch: number;
+}
 export declare function emptyTopicRegistryState(): TopicRegistryState;
 /**
  * In-memory registry over a serialisable state. Topic creation is injected via
@@ -199,7 +210,14 @@ export declare class TopicRegistry {
     captureDeleteAuthority(sessionId: string): TopicDeleteAuthoritySnapshot;
     /** Restore a failed delete fence only while its exact authority mutation remains current. */
     restoreDeleteAuthority(snapshot: TopicDeleteAuthoritySnapshot): boolean;
-    /** Restore the exact delete fence after a failed compensation publication. */
+    /**
+     * Restore the exact delete fence after a failed compensation publication.
+     *
+     * Settlement rebuilds derived routes, which can make a surviving colliding
+     * record routable. Rebuild again on successful restoration so the reinstated
+     * fence re-quarantines the topic id instead of leaving inbound routing open to
+     * the collision partner despite the restored fence.
+     */
     restoreDeleteFence(snapshot: TopicDeleteAuthoritySnapshot): boolean;
     /** Fence new work before the remote delete starts, including an absent in-flight create. */
     beginDelete(sessionId: string): TopicRecord | undefined;
@@ -209,8 +227,50 @@ export declare class TopicRegistry {
     fenceAcceptedCreateForLease(sessionId: string, topicId: string, creationLeaseEpoch: number, now?: () => number, name?: string, binding?: TopicEndpointBinding): TopicRecord | undefined;
     /** Wait for a revoked create to settle before admitting a later lifecycle epoch. */
     awaitInflight(sessionId: string): Promise<void>;
-    /** Remove only after a definite remote deletion; ambiguity deliberately retains its fence. */
-    settleDelete(sessionId: string, topicId: string): boolean;
+    /**
+     * Phase 1 of settling a definite remote delete: remove the record while
+     * deliberately RETAINING its topic-id quarantine.
+     *
+     * `dispatchedAuthorityEpoch` is the authority epoch the caller held when it
+     * dispatched the remote delete. Settlement requires that epoch to still equal
+     * both the record's own authority epoch and the registry's current epoch for
+     * the session, so a held earlier delete can never settle a newer fence: if a
+     * scan or close-started delete re-fenced the same session/topic after this
+     * delete was dispatched, the stale definite result is refused and the newer
+     * `delete_pending` record plus its topic-id quarantine stay intact.
+     *
+     * An epoch outside the safe-integer range cannot identify a generation, and at
+     * `Number.MAX_SAFE_INTEGER` epoch advancement has saturated so distinct
+     * generations are no longer distinguishable. Both fail closed: settlement can
+     * no longer be proven fresh, so the fence is kept.
+     *
+     * Derived routing tables are deliberately NOT rebuilt here. Until the cleared
+     * snapshot is durably persisted the clear is not authoritative, so publishing
+     * routes now would make a colliding survivor routable (and the settled id
+     * adoptable) during the held write, and a failed persist would re-quarantine
+     * too late. Publish with {@link commitSettledDelete} once the persist
+     * succeeds, or undo with {@link rollbackSettledDelete} when it fails.
+     */
+    settleDelete(sessionId: string, topicId: string, dispatchedAuthorityEpoch: number): TopicSettledDelete | undefined;
+    /**
+     * Phase 2: publish derived routing tables once the cleared state is durable.
+     *
+     * Only here does the settled topic id lose its quarantine, so a surviving
+     * colliding record becomes routable and a settled id becomes adoptable without
+     * waiting for a daemon restart.
+     */
+    commitSettledDelete(settled: TopicSettledDelete): boolean;
+    /**
+     * Compare-and-swap undo for a settlement whose durable clear failed.
+     *
+     * Restoration applies only while the registry still holds exactly the state
+     * that this settlement produced: the settlement is still awaiting commit, the
+     * session still has no record, and the session epoch is still the settled
+     * epoch. Any mismatch means a newer generation intervened, so the restore is
+     * refused and the newer state is left untouched. A refused settlement produced
+     * no token, so it can never reach this path.
+     */
+    rollbackSettledDelete(settled: TopicSettledDelete): boolean;
     /** Remove a topic record immediately for local/test cleanup compatibility. */
     delete(sessionId: string): boolean;
     /** Serialise active records plus unpublished staged creates for atomic commit. */

package/dist/types/session/agent-session.d.ts

@@ -13,8 +13,9 @@
  * Modes use this class and add their own I/O layer on top.
  */
 import { type Agent, type AgentContext, type AgentEvent, type AgentLoopConfig, type AgentMessage, type AgentState, type AgentTool, type MidRunMaintenanceOutcome, type RunSettlementProof, type StablePrefixSnapshot, ThinkingLevel } from "@gajae-code/agent-core";
+import type { AttemptScope } from "@gajae-code/agent-core/attempt-scope";
 import { type CompactionResult, type EmergencyCompactionSample } from "@gajae-code/agent-core/compaction";
-import type { AssistantMessage, Effort, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ServiceTier, SimpleStreamOptions, TextContent, ToolCall, ToolChoice, Usage, UsageReport } from "@gajae-code/ai";
+import type { AssistantMessage, AttemptScopeRef, Effort, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ServiceTier, SimpleStreamOptions, TextContent, ToolCall, ToolChoice, Usage, UsageReport } from "@gajae-code/ai";
 import { type BtwTextExchange } from "./btw-contract";
 export interface ForkContextSeedMetadata {
     sourceSessionId: string;
@@ -231,7 +232,7 @@ export interface AgentSessionConfig {
     /** Tool-session factory context used to lazily attach workflow-gate-only tools. */
     workflowGateToolSession?: ToolSession;
     /** Current session pre-LLM message transform pipeline */
-    transformContext?: (messages: AgentMessage[], signal?: AbortSignal) => AgentMessage[] | Promise<AgentMessage[]>;
+    transformContext?: (messages: AgentMessage[], signal?: AbortSignal, scope?: AttemptScopeRef) => AgentMessage[] | Promise<AgentMessage[]>;
     /** Provider payload hook used by the active session request path */
     onPayload?: SimpleStreamOptions["onPayload"];
     /** Provider response hook used by the active session request path */
@@ -815,9 +816,9 @@ export declare class AgentSession {
     /** Build display context from an unpublished successor without changing active session state. @internal */
     buildPreparedDisplaySessionContext(prepared: PreparedNewSession): SessionContext;
     /** Convert session messages using the same pre-LLM pipeline as the active session. */
-    convertMessagesToLlm(messages: AgentMessage[], signal?: AbortSignal): Promise<Message[]>;
+    convertMessagesToLlm(messages: AgentMessage[], signal?: AbortSignal, scope?: AttemptScope): Promise<Message[]>;
     /** Apply session-level stream hooks to a direct side request. */
-    prepareSimpleStreamOptions(options: SimpleStreamOptions, provider?: string): SimpleStreamOptions;
+    prepareSimpleStreamOptions(options: SimpleStreamOptions, provider?: string, scope?: AttemptScope): SimpleStreamOptions;
     /** Current steering mode */
     get steeringMode(): "all" | "one-at-a-time";
     /** Current follow-up mode */

package/dist/types/session/attempt-record-store.d.ts

@@ -0,0 +1,19 @@
+import type { AttemptScope, AttemptScopeAuthority } from "@gajae-code/agent-core/attempt-scope";
+export type AttemptExecutionState = "unknown" | "clean" | "executed";
+/**
+ * Tracks whether an attempt has had an extension handler delivered to it.
+ *
+ * Records are deliberately established in two phases: allocation registers an
+ * `unknown` record, then the session marks it `clean` immediately before the
+ * first handler-capable delivery can occur. The runner changes a clean record
+ * to `executed` immediately before invoking its first handler.
+ */
+export declare class AttemptRecordStore {
+    #private;
+    constructor(authority: AttemptScopeAuthority);
+    register(scope: AttemptScope): boolean;
+    establishClean(scope: AttemptScope): boolean;
+    markExecuted(scope: AttemptScope): boolean;
+    isClean(scope: AttemptScope): boolean;
+    retire(scope: AttemptScope): boolean;
+}

package/dist/types/session/session-manager.d.ts

@@ -329,6 +329,7 @@ export interface ResumeSessionIdentity {
     sessionId: string;
     dev: bigint;
     ino: bigint;
+    nlink?: bigint;
     size: number;
     mtimeMs: number;
     mtimeNs: bigint;

package/dist/types/session/session-storage.d.ts

@@ -3,6 +3,7 @@ import { type ManagedDirectoryRoot } from "./internal/managed-session-storage";
 export interface SessionStorageStat {
     dev: bigint;
     ino: bigint;
+    nlink?: bigint;
     size: number;
     mtimeMs: number;
     mtimeNs: bigint;
@@ -148,6 +149,7 @@ export interface SessionStorage {
 export interface SessionStorageFileIdentity {
     dev: bigint;
     ino: bigint;
+    nlink?: bigint;
     size: number;
     mtimeNs: bigint;
     sha256: string;
@@ -181,12 +183,17 @@ export interface VerifiedSessionDeleteTarget {
     cwd: string;
     /** Expected transcript file `(dev, ino)` captured at authorization. */
     transcriptIdentity: SessionStorageFileIdentity;
+    transcriptParentIdentity?: {
+        dev: bigint;
+        ino: bigint;
+    };
     /**
      * For retry after an `artifacts` `cleanup_pending`: the recorded artifact
      * directory identity to re-accept. A replacement/different artifact directory
      * fails closed. Omit on first attempt or to accept recorded absence.
      */
     expectedArtifactsIdentity?: SessionStorageFileIdentity;
+    artifactsAbsentAtAuthorization?: true;
     /** Stable native recursive-tree evidence captured before artifact detachment. */
     expectedArtifactsTree?: NativeDirectoryTreeSnapshot;
     /** Identity-bound quarantine path retained when recursive artifact cleanup failed. */
@@ -256,6 +263,7 @@ type NativeDirectoryTreeEntry = {
     kind: string;
     dev: string;
     ino: string;
+    nlink: string;
     size: string;
     mtimeNs: string;
     ctimeNs: string;

package/dist/types/task/receipt.d.ts

@@ -43,6 +43,7 @@ export interface TaskResultReceipt {
         summary: string;
     };
     errorSummary?: string;
+    duplicateDisposition?: SingleResult["duplicateDisposition"];
     abortSummary?: string;
     preview: string;
     previewTruncated: boolean;

package/dist/types/task/types.d.ts

@@ -65,6 +65,10 @@ export declare const taskItemSchema: z.ZodObject<{
         head: z.ZodOptional<z.ZodString>;
         branch: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
+    duplicate_policy: z.ZodOptional<z.ZodEnum<{
+        supersede: "supersede";
+        warn: "warn";
+    }>>;
 }, z.core.$strip>;
 export type TaskItem = z.infer<typeof taskItemSchema>;
 export declare const taskSchema: z.ZodObject<{
@@ -93,6 +97,10 @@ export declare const taskSchema: z.ZodObject<{
             head: z.ZodOptional<z.ZodString>;
             branch: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
+        duplicate_policy: z.ZodOptional<z.ZodEnum<{
+            supersede: "supersede";
+            warn: "warn";
+        }>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -128,6 +136,10 @@ export declare const taskSchemaNoIsolation: z.ZodObject<{
             head: z.ZodOptional<z.ZodString>;
             branch: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
+        duplicate_policy: z.ZodOptional<z.ZodEnum<{
+            supersede: "supersede";
+            warn: "warn";
+        }>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -163,6 +175,10 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             head: z.ZodOptional<z.ZodString>;
             branch: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
+        duplicate_policy: z.ZodOptional<z.ZodEnum<{
+            supersede: "supersede";
+            warn: "warn";
+        }>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -197,6 +213,10 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             head: z.ZodOptional<z.ZodString>;
             branch: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
+        duplicate_policy: z.ZodOptional<z.ZodEnum<{
+            supersede: "supersede";
+            warn: "warn";
+        }>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -231,6 +251,10 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             head: z.ZodOptional<z.ZodString>;
             branch: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
+        duplicate_policy: z.ZodOptional<z.ZodEnum<{
+            supersede: "supersede";
+            warn: "warn";
+        }>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -265,6 +289,10 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             head: z.ZodOptional<z.ZodString>;
             branch: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
+        duplicate_policy: z.ZodOptional<z.ZodEnum<{
+            supersede: "supersede";
+            warn: "warn";
+        }>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -299,6 +327,10 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             head: z.ZodOptional<z.ZodString>;
             branch: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
+        duplicate_policy: z.ZodOptional<z.ZodEnum<{
+            supersede: "supersede";
+            warn: "warn";
+        }>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -333,6 +365,10 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             head: z.ZodOptional<z.ZodString>;
             branch: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
+        duplicate_policy: z.ZodOptional<z.ZodEnum<{
+            supersede: "supersede";
+            warn: "warn";
+        }>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -357,6 +393,7 @@ export interface TaskParams {
     spawnPlan?: SpawnPlanReceipt;
     tasks: TaskItem[];
     isolated?: boolean;
+    duplicate_policy?: "warn" | "supersede";
 }
 /** A code review finding reported by the reviewer agent */
 export interface ReviewFinding {
@@ -502,6 +539,11 @@ export interface TaskRecoveryArtifactRef {
     /** Recovery artifacts remain readable for the parent session lifetime. */
     durability: "session";
 }
+/** Bounded duplicate-launch disposition carried into task receipts. */
+export interface DuplicateDisposition {
+    action: "warned" | "superseded";
+    predecessorIds: string[];
+}
 export interface TaskPersistenceResult {
     outcome: "applied" | "no_changes" | "recovery_available";
     ownerWorktreeApplied: boolean;
@@ -537,6 +579,7 @@ export interface SingleResult {
     setupFailure?: SetupFailureSummary;
     aborted?: boolean;
     abortReason?: string;
+    duplicateDisposition?: DuplicateDisposition;
     paused?: boolean;
     /** Aggregated usage from the subprocess, accumulated incrementally from message_end events. */
     usage?: Usage;

package/dist/types/tools/subagent.d.ts

@@ -16,6 +16,11 @@ declare const subagentSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     message: z.ZodOptional<z.ZodString>;
     pause: z.ZodOptional<z.ZodBoolean>;
+    condition: z.ZodOptional<z.ZodEnum<{
+        all_terminal: "all_terminal";
+        any_terminal: "any_terminal";
+    }>>;
+    heartbeat_ms: z.ZodOptional<z.ZodNumber>;
     timeout_ms: z.ZodOptional<z.ZodNumber>;
     limit: z.ZodOptional<z.ZodNumber>;
     verbosity: z.ZodOptional<z.ZodEnum<{
@@ -65,6 +70,11 @@ export interface SubagentToolDetails {
     subagents: SubagentSnapshot[];
     /** Await outcome for a live await receipt; omitted when no wait was started. */
     awaitOutcome?: SubagentAwaitOutcome;
+    waitOutcome?: "completed" | "timed_out_wait" | "interrupted";
+    condition?: "all_terminal" | "any_terminal";
+    heartbeatMs?: number;
+    terminalIds?: string[];
+    acknowledgedTerminalIds?: string[];
     /** True only when the parent await was interrupted; the child was not cancelled. */
     interrupted?: true;
 }
@@ -89,6 +99,11 @@ export declare class SubagentTool implements AgentTool<typeof subagentSchema, Su
         id: z.ZodOptional<z.ZodString>;
         message: z.ZodOptional<z.ZodString>;
         pause: z.ZodOptional<z.ZodBoolean>;
+        condition: z.ZodOptional<z.ZodEnum<{
+            all_terminal: "all_terminal";
+            any_terminal: "any_terminal";
+        }>>;
+        heartbeat_ms: z.ZodOptional<z.ZodNumber>;
         timeout_ms: z.ZodOptional<z.ZodNumber>;
         limit: z.ZodOptional<z.ZodNumber>;
         verbosity: z.ZodOptional<z.ZodEnum<{

package/dist/types/tools/todo-write.d.ts

@@ -1,4 +1,5 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
+import type { RawArgumentValidationResult } from "@gajae-code/ai/types";
 import type { Component } from "@gajae-code/tui";
 import * as z from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
@@ -25,6 +26,7 @@ export interface TodoWriteToolDetails {
     phases: TodoPhase[];
     storage: "session" | "memory";
 }
+declare function validateRawTodoArguments(arguments_: Record<string, unknown>): RawArgumentValidationResult;
 declare const todoWriteSchema: z.ZodObject<{
     ops: z.ZodArray<z.ZodObject<{
         op: z.ZodEnum<{
@@ -88,6 +90,7 @@ export declare class TodoWriteTool implements AgentTool<typeof todoWriteSchema,
             text: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
+    readonly rawArgumentValidation: typeof validateRawTodoArguments;
     readonly concurrency = "exclusive";
     readonly strict = true;
     readonly loadMode = "discoverable";

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.12.5",
+	"version": "0.12.7",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -53,13 +53,13 @@
 		"@agentclientprotocol/sdk": "1.3.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.12.5",
-		"@gajae-code/agent-core": "0.12.5",
-		"@gajae-code/ai": "0.12.5",
-		"@gajae-code/bridge-client": "0.12.5",
-		"@gajae-code/natives": "0.12.5",
-		"@gajae-code/tui": "0.12.5",
-		"@gajae-code/utils": "0.12.5",
+		"@gajae-code/stats": "0.12.7",
+		"@gajae-code/agent-core": "0.12.7",
+		"@gajae-code/ai": "0.12.7",
+		"@gajae-code/bridge-client": "0.12.7",
+		"@gajae-code/natives": "0.12.7",
+		"@gajae-code/tui": "0.12.7",
+		"@gajae-code/utils": "0.12.7",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",