@tomkapa/tayto 0.3.1 → 0.4.0

package/dist/index.js

@@ -8,10 +8,14 @@ import {
   TaskType,
   UIDependencyType,
   WORK_TYPES,
+  detectGitRemote,
+  err,
   getTaskLevel,
   isTerminalStatus,
-  logger
-} from "./chunk-FUNYPBWJ.js";
+  logger,
+  midpoint,
+  ok
+} from "./chunk-74Q55TOV.js";
 
 // src/config/index.ts
 import { mkdirSync } from "fs";
@@ -105,14 +109,6 @@ async function shutdownTelemetry() {
   }
 }
 
-// src/types/common.ts
-function ok(value) {
-  return { ok: true, value };
-}
-function err(error) {
-  return { ok: false, error };
-}
-
 // src/errors/app-error.ts
 var AppError = class extends Error {
   constructor(code, message, cause) {
@@ -155,6 +151,7 @@ function rowToProject(row) {
     name: row.name,
     description: row.description,
     isDefault: row.is_default === 1,
+    gitRemote: row.git_remote,
     createdAt: row.created_at,
     updatedAt: row.updated_at
   };
@@ -173,14 +170,15 @@ var SqliteProjectRepository = class {
           this.db.prepare("UPDATE projects SET is_default = 0 WHERE is_default = 1").run();
         }
         this.db.prepare(
-          `INSERT INTO projects (id, key, name, description, is_default, created_at, updated_at)
-             VALUES (?, ?, ?, ?, ?, ?, ?)`
+          `INSERT INTO projects (id, key, name, description, is_default, git_remote, created_at, updated_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
         ).run(
           id,
           input.key,
           input.name,
           input.description ?? "",
           input.isDefault ? 1 : 0,
+          input.gitRemote ?? null,
           now,
           now
         );
@@ -191,6 +189,15 @@ var SqliteProjectRepository = class {
         return ok(rowToProject(row));
       } catch (e) {
         if (e instanceof Error && e.message.includes("UNIQUE constraint")) {
+          if (e.message.includes("git_remote")) {
+            return err(
+              new AppError(
+                "DUPLICATE",
+                `Git remote already linked to another project: ${input.gitRemote}`,
+                e
+              )
+            );
+          }
           return err(new AppError("DUPLICATE", `Project name already exists: ${input.name}`, e));
         }
         return err(new AppError("DB_ERROR", "Failed to insert project", e));
@@ -221,6 +228,14 @@ var SqliteProjectRepository = class {
       return err(new AppError("DB_ERROR", "Failed to find project by name", e));
     }
   }
+  findByGitRemote(remote) {
+    try {
+      const row = this.db.prepare(`SELECT * FROM projects WHERE git_remote = ? AND ${NOT_DELETED}`).get(remote);
+      return ok(row ? rowToProject(row) : null);
+    } catch (e) {
+      return err(new AppError("DB_ERROR", "Failed to find project by git remote", e));
+    }
+  }
   findDefault() {
     try {
       const row = this.db.prepare(`SELECT * FROM projects WHERE is_default = 1 AND ${NOT_DELETED}`).get();
@@ -250,12 +265,13 @@ var SqliteProjectRepository = class {
         }
         this.db.prepare(
           `UPDATE projects SET
-               name = ?, description = ?, is_default = ?, updated_at = ?
+               name = ?, description = ?, is_default = ?, git_remote = ?, updated_at = ?
              WHERE id = ?`
         ).run(
           input.name ?? existing.name,
           input.description ?? existing.description,
           input.isDefault !== void 0 ? input.isDefault ? 1 : 0 : existing.is_default,
+          input.gitRemote !== void 0 ? input.gitRemote : existing.git_remote,
           now,
           id
         );
@@ -266,6 +282,11 @@ var SqliteProjectRepository = class {
         return ok(rowToProject(row));
       } catch (e) {
         if (e instanceof Error && e.message.includes("UNIQUE constraint")) {
+          if (e.message.includes("git_remote")) {
+            return err(
+              new AppError("DUPLICATE", `Git remote already linked to another project`, e)
+            );
+          }
           return err(new AppError("DUPLICATE", `Project name already exists`, e));
         }
         return err(new AppError("DB_ERROR", "Failed to update project", e));
@@ -332,18 +353,9 @@ var SqliteTaskRepository = class {
       try {
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const level = getTaskLevel(input.type);
-        const maxActiveResult = this.getMaxActiveRankByLevel(input.projectId, level);
-        if (!maxActiveResult.ok) return maxActiveResult;
-        const maxActiveRank = maxActiveResult.value;
-        const minTerminalResult = this.getMinTerminalRankByLevel(input.projectId, level);
-        if (!minTerminalResult.ok) return minTerminalResult;
-        const minTerminalRank = minTerminalResult.value;
-        let rank;
-        if (minTerminalRank !== null && minTerminalRank > maxActiveRank) {
-          rank = maxActiveRank > 0 ? (maxActiveRank + minTerminalRank) / 2 : minTerminalRank - RANK_GAP;
-        } else {
-          rank = maxActiveRank + RANK_GAP;
-        }
+        const rankResult = this.computeInsertRank(input.projectId, level);
+        if (!rankResult.ok) return rankResult;
+        const rank = rankResult.value;
         this.db.prepare(
           `INSERT INTO tasks (id, project_id, parent_id, name, description, type, status, rank, technical_notes, additional_requirements, created_at, updated_at)
              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
@@ -630,6 +642,104 @@ _${now}_
       return err(new AppError("DB_ERROR", "Failed to get ranked non-terminal tasks by level", e));
     }
   }
+  rebalanceByLevel(projectId, level) {
+    return logger.startSpan("TaskRepository.rebalanceByLevel", () => {
+      try {
+        const types = this.getTypesForLevel(level);
+        const typePlaceholders = types.map(() => "?").join(", ");
+        const rows = this.db.prepare(
+          `SELECT * FROM tasks
+             WHERE project_id = ? AND ${NOT_DELETED} AND type IN (${typePlaceholders})
+             ORDER BY
+               CASE WHEN status IN (${TERMINAL_PLACEHOLDERS}) THEN 1 ELSE 0 END ASC,
+               rank ASC,
+               id ASC`
+        ).all(projectId, ...types, ...TERMINAL_STATUS_ARRAY);
+        if (rows.length === 0) return ok(void 0);
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const updateStmt = this.db.prepare(
+          "UPDATE tasks SET rank = ?, updated_at = ? WHERE id = ?"
+        );
+        this.db.exec("BEGIN");
+        try {
+          for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            if (!row) continue;
+            const newRank = (i + 1) * RANK_GAP;
+            if (row.rank === newRank) continue;
+            updateStmt.run(newRank, now, row.id);
+          }
+          this.db.exec("COMMIT");
+        } catch (inner) {
+          this.db.exec("ROLLBACK");
+          throw inner;
+        }
+        return ok(void 0);
+      } catch (e) {
+        return err(new AppError("DB_ERROR", "Failed to rebalance ranks by level", e));
+      }
+    });
+  }
+  /**
+   * Fetch `(maxActive, minTerminal)` for a level in a single SQL round-trip.
+   * Used by the insert hot path — faster than calling the two separate
+   * level accessors in sequence.
+   */
+  getRankBoundsByLevel(projectId, level) {
+    try {
+      const types = this.getTypesForLevel(level);
+      const typePlaceholders = types.map(() => "?").join(", ");
+      const row = this.db.prepare(
+        `SELECT
+             MAX(CASE WHEN status NOT IN (${TERMINAL_PLACEHOLDERS}) THEN rank END) AS max_active,
+             MIN(CASE WHEN status IN (${TERMINAL_PLACEHOLDERS}) THEN rank END) AS min_terminal
+           FROM tasks
+           WHERE project_id = ? AND ${NOT_DELETED} AND type IN (${typePlaceholders})`
+      ).get(...TERMINAL_STATUS_ARRAY, ...TERMINAL_STATUS_ARRAY, projectId, ...types);
+      return ok({
+        maxActive: row?.max_active ?? 0,
+        minTerminal: row?.min_terminal ?? null
+      });
+    } catch (e) {
+      return err(new AppError("DB_ERROR", "Failed to get rank bounds by level", e));
+    }
+  }
+  /**
+   * Compute a fresh rank for a new active task at the given level.
+   *
+   * Wedges the new task between the last active task and the first terminal
+   * task. If the midpoint collapses against either endpoint, or if the
+   * level is already in a corrupt interleaved state (terminal rank ≤
+   * active rank), rebalance the level once and recompute.
+   */
+  computeInsertRank(projectId, level) {
+    const attempt = () => {
+      const boundsResult = this.getRankBoundsByLevel(projectId, level);
+      if (!boundsResult.ok) return boundsResult;
+      const { maxActive, minTerminal } = boundsResult.value;
+      if (minTerminal === null) {
+        return ok(maxActive + RANK_GAP);
+      }
+      if (minTerminal <= maxActive) {
+        return ok(null);
+      }
+      if (maxActive <= 0) {
+        return ok(minTerminal - RANK_GAP);
+      }
+      return ok(midpoint(maxActive, minTerminal));
+    };
+    const first = attempt();
+    if (!first.ok) return first;
+    if (first.value !== null) return ok(first.value);
+    const rebalanceResult = this.rebalanceByLevel(projectId, level);
+    if (!rebalanceResult.ok) return rebalanceResult;
+    const second = attempt();
+    if (!second.ok) return second;
+    if (second.value === null) {
+      return err(new AppError("DB_ERROR", "Rank computation did not converge after rebalance"));
+    }
+    return ok(second.value);
+  }
   search(query, projectId) {
     return logger.startSpan("TaskRepository.search", () => {
       try {
@@ -852,20 +962,24 @@ var CreateProjectSchema = z.object({
   name: z.string().min(1, "Project name is required").max(255),
   key: z.string().min(2, "Project key must be at least 2 characters").max(7, "Project key must be at most 7 characters").regex(/^[A-Za-z0-9]+$/, "Project key must contain only letters and digits").transform((v) => v.toUpperCase()).optional(),
   description: z.string().max(5e3).optional(),
-  isDefault: z.boolean().optional()
+  isDefault: z.boolean().optional(),
+  gitRemote: z.string().min(1, "Git remote URL must not be empty").nullable().optional()
 });
 var UpdateProjectSchema = z.object({
   name: z.string().min(1).max(255).optional(),
   description: z.string().max(5e3).optional(),
-  isDefault: z.boolean().optional()
+  isDefault: z.boolean().optional(),
+  gitRemote: z.string().min(1, "Git remote URL must not be empty").nullable().optional()
 });
 
 // src/service/project.service.ts
 var ProjectServiceImpl = class {
-  constructor(repo) {
+  constructor(repo, detectRemote = detectGitRemote) {
     this.repo = repo;
+    this.detectRemote = detectRemote;
   }
   repo;
+  detectRemote;
   createProject(input) {
     return logger.startSpan("ProjectService.createProject", () => {
       const parsed = CreateProjectSchema.safeParse(input);
@@ -947,6 +1061,58 @@ var ProjectServiceImpl = class {
       );
     });
   }
+  resolveProjectWithGit(idOrName, cwd) {
+    return logger.startSpan("ProjectService.resolveProjectWithGit", () => {
+      if (idOrName) {
+        return this.resolveProject(idOrName);
+      }
+      const remoteResult = this.detectRemote(cwd);
+      if (remoteResult.ok && remoteResult.value) {
+        const byRemote = this.repo.findByGitRemote(remoteResult.value);
+        if (!byRemote.ok) return byRemote;
+        if (byRemote.value) {
+          logger.info(
+            `resolveProjectWithGit: matched git remote to project key=${byRemote.value.key}`
+          );
+          return ok(byRemote.value);
+        }
+      }
+      return this.resolveProject();
+    });
+  }
+  linkGitRemote(idOrName, remote) {
+    return logger.startSpan("ProjectService.linkGitRemote", () => {
+      const resolved = this.resolveProject(idOrName);
+      if (!resolved.ok) return resolved;
+      let url = remote;
+      if (!url) {
+        const detected = this.detectRemote();
+        if (!detected.ok) return detected;
+        if (!detected.value) {
+          return err(
+            new AppError(
+              "NOT_FOUND",
+              "No git remote detected in current directory. Use --remote <url> to specify one explicitly."
+            )
+          );
+        }
+        url = detected.value;
+      }
+      return this.repo.update(resolved.value.id, { gitRemote: url });
+    });
+  }
+  unlinkGitRemote(idOrName) {
+    return logger.startSpan("ProjectService.unlinkGitRemote", () => {
+      const resolved = this.resolveProject(idOrName);
+      if (!resolved.ok) return resolved;
+      if (!resolved.value.gitRemote) {
+        return err(
+          new AppError("NOT_FOUND", `Project "${resolved.value.name}" has no linked git remote.`)
+        );
+      }
+      return this.repo.update(resolved.value.id, { gitRemote: null });
+    });
+  }
   nextTaskId(project) {
     return logger.startSpan("ProjectService.nextTaskId", () => {
       const counterResult = this.repo.incrementTaskCounter(project.id);
@@ -1001,7 +1167,11 @@ var RerankTaskSchema = z2.object({
   taskId: z2.string().min(1, "Task id is required"),
   afterId: z2.string().optional(),
   beforeId: z2.string().optional(),
-  position: z2.number().int().min(1).optional()
+  position: z2.number().int().min(1).optional(),
+  /** Move to the top of active tasks (highest priority). */
+  top: z2.boolean().optional(),
+  /** Move to the bottom of active tasks, kept above terminal (done/cancelled) tasks. */
+  bottom: z2.boolean().optional()
 });
 
 // src/service/task.service.ts
@@ -1074,12 +1244,12 @@ var TaskServiceImpl = class {
       if (!parsed.success) {
         return err(new AppError("VALIDATION", parsed.error.message));
       }
-      let resolvedFilter = parsed.data;
-      if (parsed.data.projectId) {
-        const projectResult = this.projectService.resolveProject(parsed.data.projectId);
-        if (!projectResult.ok) return projectResult;
-        resolvedFilter = { ...resolvedFilter, projectId: projectResult.value.id };
-      }
+      const projectResult = this.projectService.resolveProject(parsed.data.projectId);
+      if (!projectResult.ok) return projectResult;
+      const resolvedFilter = {
+        ...parsed.data,
+        projectId: projectResult.value.id
+      };
       return this.repo.findMany(resolvedFilter);
     });
   }
@@ -1224,13 +1394,13 @@ var TaskServiceImpl = class {
       if (!parsed.success) {
         return err(new AppError("VALIDATION", parsed.error.message));
       }
-      const { taskId, afterId, beforeId, position } = parsed.data;
-      const specifiedCount = [afterId, beforeId, position].filter((v) => v !== void 0).length;
+      const { taskId, afterId, beforeId, position, top, bottom } = parsed.data;
+      const specifiedCount = [afterId, beforeId, position].filter((v) => v !== void 0).length + (top ? 1 : 0) + (bottom ? 1 : 0);
       if (specifiedCount !== 1) {
         return err(
           new AppError(
             "VALIDATION",
-            "Exactly one of --after, --before, or --position must be specified"
+            "Exactly one of --after, --before, --position, --top, or --bottom must be specified"
           )
         );
       }
@@ -1253,77 +1423,102 @@ var TaskServiceImpl = class {
       const projectResult = this.projectService.resolveProject(projectRef);
       if (!projectResult.ok) return projectResult;
       const projectId = projectResult.value.id;
-      const rankedResult = this.repo.getRankedNonTerminalTasksByLevel(projectId, taskLevel);
-      if (!rankedResult.ok) return rankedResult;
-      const ranked = rankedResult.value.filter((t) => t.id !== taskId);
-      let newRank;
-      if (afterId) {
-        const anchor = ranked.find((t) => t.id === afterId);
-        if (!anchor) {
-          return err(
-            new AppError("NOT_FOUND", `Anchor task not found among active tasks: ${afterId}`)
-          );
+      const depService = this.getDependencyService();
+      const blockersResult = depService.listBlockers(taskId);
+      if (!blockersResult.ok) return blockersResult;
+      const constrainingBlockers = blockersResult.value.filter(
+        (b) => !isTerminalStatus(b.status) && b.projectId === projectId
+      );
+      const dependentsResult = depService.listDependents(taskId);
+      if (!dependentsResult.ok) return dependentsResult;
+      const constrainingDependents = dependentsResult.value.filter(
+        (d) => !isTerminalStatus(d.status) && d.projectId === projectId
+      );
+      const attempt = () => {
+        const rankedResult = this.repo.getRankedNonTerminalTasksByLevel(projectId, taskLevel);
+        if (!rankedResult.ok) return rankedResult;
+        const ranked = rankedResult.value.filter((t) => t.id !== taskId);
+        if (top === true) {
+          return ok(this.computeTopRank(ranked, constrainingBlockers));
         }
-        const anchorIndex = ranked.indexOf(anchor);
-        const next = ranked[anchorIndex + 1];
-        newRank = next ? (anchor.rank + next.rank) / 2 : anchor.rank + RANK_GAP;
-      } else if (beforeId) {
-        const anchor = ranked.find((t) => t.id === beforeId);
-        if (!anchor) {
-          return err(
-            new AppError("NOT_FOUND", `Anchor task not found among active tasks: ${beforeId}`)
+        if (bottom === true) {
+          const minTerminalResult = this.repo.getMinTerminalRankByLevel(projectId, taskLevel);
+          if (!minTerminalResult.ok) return minTerminalResult;
+          return ok(
+            this.computeBottomRank(ranked, minTerminalResult.value, constrainingDependents)
           );
         }
-        const anchorIndex = ranked.indexOf(anchor);
-        const prev = ranked[anchorIndex - 1];
-        newRank = prev ? (prev.rank + anchor.rank) / 2 : anchor.rank - RANK_GAP;
-      } else {
+        if (afterId) {
+          const anchorIndex = ranked.findIndex((t) => t.id === afterId);
+          const anchor = ranked[anchorIndex];
+          if (!anchor) {
+            return err(
+              new AppError("NOT_FOUND", `Anchor task not found among active tasks: ${afterId}`)
+            );
+          }
+          const next = ranked[anchorIndex + 1];
+          return ok(next ? midpoint(anchor.rank, next.rank) : anchor.rank + RANK_GAP);
+        }
+        if (beforeId) {
+          const anchorIndex = ranked.findIndex((t) => t.id === beforeId);
+          const anchor = ranked[anchorIndex];
+          if (!anchor) {
+            return err(
+              new AppError("NOT_FOUND", `Anchor task not found among active tasks: ${beforeId}`)
+            );
+          }
+          const prev = ranked[anchorIndex - 1];
+          return ok(prev ? midpoint(prev.rank, anchor.rank) : anchor.rank - RANK_GAP);
+        }
         const pos = position;
         if (pos < 1) {
           return err(new AppError("VALIDATION", "Position must be >= 1"));
         }
         if (pos === 1) {
-          const first = ranked[0];
-          newRank = first ? first.rank - RANK_GAP : RANK_GAP;
-        } else if (pos > ranked.length) {
-          const last = ranked[ranked.length - 1];
-          newRank = last ? last.rank + RANK_GAP : RANK_GAP;
-        } else {
-          const above = ranked[pos - 2];
-          const below = ranked[pos - 1];
-          if (!above || !below) {
-            return err(new AppError("DB_ERROR", "Unexpected missing neighbor tasks"));
-          }
-          newRank = (above.rank + below.rank) / 2;
+          return ok(this.computeTopRank(ranked));
+        }
+        if (pos > ranked.length) {
+          const minTerminalResult = this.repo.getMinTerminalRankByLevel(projectId, taskLevel);
+          if (!minTerminalResult.ok) return minTerminalResult;
+          return ok(this.computeBottomRank(ranked, minTerminalResult.value));
+        }
+        const above = ranked[pos - 2];
+        const below = ranked[pos - 1];
+        if (!above || !below) {
+          return err(new AppError("DB_ERROR", "Unexpected missing neighbor tasks"));
+        }
+        return ok(midpoint(above.rank, below.rank));
+      };
+      let computed = attempt();
+      if (!computed.ok) return computed;
+      if (computed.value === null) {
+        const rb = this.repo.rebalanceByLevel(projectId, taskLevel);
+        if (!rb.ok) return rb;
+        computed = attempt();
+        if (!computed.ok) return computed;
+        if (computed.value === null) {
+          return err(new AppError("DB_ERROR", "Rank computation did not converge after rebalance"));
         }
       }
-      const depService = this.getDependencyService();
-      const blockersResult = depService.listBlockers(taskId);
-      if (blockersResult.ok) {
-        for (const blocker of blockersResult.value) {
-          if (isTerminalStatus(blocker.status)) continue;
-          if (blocker.projectId === projectId && newRank < blocker.rank) {
-            return err(
-              new AppError(
-                "VALIDATION",
-                `Cannot rank above blocker "${blocker.id}" (${blocker.name}). Complete or remove the dependency first.`
-              )
-            );
-          }
+      const newRank = computed.value;
+      for (const blocker of constrainingBlockers) {
+        if (newRank < blocker.rank) {
+          return err(
+            new AppError(
+              "VALIDATION",
+              `Cannot rank above blocker "${blocker.id}" (${blocker.name}). Complete or remove the dependency first.`
+            )
+          );
         }
       }
-      const dependentsResult = depService.listDependents(taskId);
-      if (dependentsResult.ok) {
-        for (const dep of dependentsResult.value) {
-          if (isTerminalStatus(dep.status)) continue;
-          if (dep.projectId === projectId && newRank > dep.rank) {
-            return err(
-              new AppError(
-                "VALIDATION",
-                `Cannot rank below dependent "${dep.id}" (${dep.name}). Complete or remove the dependency first.`
-              )
-            );
-          }
+      for (const dep of constrainingDependents) {
+        if (newRank > dep.rank) {
+          return err(
+            new AppError(
+              "VALIDATION",
+              `Cannot rank below dependent "${dep.id}" (${dep.name}). Complete or remove the dependency first.`
+            )
+          );
         }
       }
       return this.repo.rerank(taskId, newRank);
@@ -1334,15 +1529,53 @@ var TaskServiceImpl = class {
       if (!query.trim()) {
         return err(new AppError("VALIDATION", "Search query cannot be empty"));
       }
-      let projectId;
-      if (projectIdOrName) {
-        const projectResult = this.projectService.resolveProject(projectIdOrName);
-        if (!projectResult.ok) return projectResult;
-        projectId = projectResult.value.id;
-      }
-      return this.repo.search(query, projectId);
+      const projectResult = this.projectService.resolveProject(projectIdOrName);
+      if (!projectResult.ok) return projectResult;
+      return this.repo.search(query, projectResult.value.id);
     });
   }
+  /**
+   * Rank for placing a task at the top of the active list. Clamps to
+   * "immediately after the highest-ranked blocker" when blockers exist
+   * rather than returning a value that would fail validation.
+   *
+   * Returns `null` to signal FP precision collapse (caller rebalances).
+   */
+  computeTopRank(ranked, constrainingBlockers = []) {
+    if (constrainingBlockers.length > 0) {
+      const highestBlocker = constrainingBlockers.reduce((a, b) => a.rank > b.rank ? a : b);
+      const idx = ranked.findIndex((t) => t.id === highestBlocker.id);
+      if (idx >= 0) {
+        const next = ranked[idx + 1];
+        return next ? midpoint(highestBlocker.rank, next.rank) : highestBlocker.rank + RANK_GAP;
+      }
+    }
+    const first = ranked[0];
+    return first ? first.rank - RANK_GAP : RANK_GAP;
+  }
+  /**
+   * Rank for placing a task at the bottom of the active list.
+   * - Stays above terminal tasks: terminal tasks live at `maxRank + RANK_GAP`
+   *   so a naive `last.rank + RANK_GAP` would collide with the most-recently
+   *   completed task.
+   * - Clamps above any dependents rather than failing validation.
+   *
+   * `minTerminal` is passed in so this helper stays pure (no DB access).
+   * Returns `null` to signal FP precision collapse.
+   */
+  computeBottomRank(ranked, minTerminal, constrainingDependents = []) {
+    if (constrainingDependents.length > 0) {
+      const lowestDependent = constrainingDependents.reduce((a, b) => a.rank < b.rank ? a : b);
+      const idx = ranked.findIndex((t) => t.id === lowestDependent.id);
+      if (idx >= 0) {
+        const prev = ranked[idx - 1];
+        return prev ? midpoint(prev.rank, lowestDependent.rank) : lowestDependent.rank - RANK_GAP;
+      }
+    }
+    const last = ranked[ranked.length - 1];
+    if (!last) return RANK_GAP;
+    return minTerminal !== null && minTerminal > last.rank ? midpoint(last.rank, minTerminal) : last.rank + RANK_GAP;
+  }
   /**
    * Auto-propagate status to the parent task after a child status change.
    * - If a child moves to in-progress and parent is backlog/todo → parent becomes in-progress.
@@ -1792,11 +2025,11 @@ var PortabilityServiceImpl = class {
 };
 
 // src/cli/container.ts
-function createContainer(db, dbPath) {
+function createContainer(db, dbPath, detectGitRemote2) {
   const projectRepo = new SqliteProjectRepository(db);
   const taskRepo = new SqliteTaskRepository(db);
   const depRepo = new SqliteDependencyRepository(db);
-  const projectService = new ProjectServiceImpl(projectRepo);
+  const projectService = new ProjectServiceImpl(projectRepo, detectGitRemote2);
   const dependencyService = new DependencyServiceImpl(depRepo, taskRepo);
   const taskService = new TaskServiceImpl(taskRepo, projectService, () => dependencyService);
   const portabilityService = new PortabilityServiceImpl(
@@ -1832,16 +2065,19 @@ function handleResult(result) {
 function registerProjectCreate(parent, container) {
   parent.command("create").description("Create a new project").requiredOption("-n, --name <name>", "Project name").option(
     "-k, --key <key>",
-    "Project key (2-10 alphanumeric chars, defaults to first 3 chars of name)"
-  ).option("-d, --description <description>", "Project description").option("--default", "Set as default project").action((opts) => {
-    const result = container.projectService.createProject({
-      name: opts.name,
-      key: opts.key,
-      description: opts.description,
-      isDefault: opts.default
-    });
-    handleResult(result);
-  });
+    "Project key (2-7 uppercase alphanumeric chars, defaults to first 3 chars of name)"
+  ).option("-d, --description <description>", "Project description").option("--default", "Set as default project").option("--git-remote <url>", "Git remote URL to associate with the project").action(
+    (opts) => {
+      const result = container.projectService.createProject({
+        name: opts.name,
+        key: opts.key,
+        description: opts.description,
+        isDefault: opts.default,
+        gitRemote: opts.gitRemote
+      });
+      handleResult(result);
+    }
+  );
 }
 
 // src/cli/commands/project/list.ts
@@ -1899,6 +2135,22 @@ function registerProjectSetDefault(parent, container) {
   });
 }
 
+// src/cli/commands/project/link.ts
+function registerProjectLink(parent, container) {
+  parent.command("link <idOrKeyOrName>").description("Link a project to a git remote (auto-detects from cwd if --remote omitted)").option("-r, --remote <url>", "Git remote URL").action((idOrKeyOrName, opts) => {
+    const result = container.projectService.linkGitRemote(idOrKeyOrName, opts.remote);
+    handleResult(result);
+  });
+}
+
+// src/cli/commands/project/unlink.ts
+function registerProjectUnlink(parent, container) {
+  parent.command("unlink <idOrKeyOrName>").description("Remove git remote link from a project").action((idOrKeyOrName) => {
+    const result = container.projectService.unlinkGitRemote(idOrKeyOrName);
+    handleResult(result);
+  });
+}
+
 // src/cli/commands/task/create.ts
 function registerTaskCreate(parent, container) {
   parent.command("create").description("Create a new task (appended to bottom of backlog)").requiredOption("-n, --name <name>", "Task name").option("-p, --project <project>", "Project id or name").option("-d, --description <description>", "Task description").option("-t, --type <type>", "Task type: epic, story, tech-debt, bug", "story").option("-s, --status <status>", "Task status", "backlog").option("--parent <parentId>", "Parent task id for subtask").option("--technical-notes <notes>", "Technical notes (markdown)").option("--additional-requirements <requirements>", "Additional requirements (markdown)").option("--depends-on <ids...>", "Task ids this task depends on (blocks relationship)").action(
@@ -2003,14 +2255,16 @@ function registerTaskBreakdown(parent, container) {
 
 // src/cli/commands/task/rank.ts
 function registerTaskRank(parent, container) {
-  parent.command("rank <id>").description("Re-rank a task in the backlog (Jira-style positioning)").option("--after <taskId>", "Place immediately after this task").option("--before <taskId>", "Place immediately before this task").option("--position <n>", "Place at 1-based position in backlog").option("-p, --project <project>", "Project id or name").action(
+  parent.command("rank <id>").description("Re-rank a task in the backlog (Jira-style positioning)").option("--after <taskId>", "Place immediately after this task").option("--before <taskId>", "Place immediately before this task").option("--position <n>", "Place at 1-based position in backlog").option("--top", "Move to the top of active tasks").option("--bottom", "Move to the bottom of active tasks (above done tasks)").option("-p, --project <project>", "Project id or name").action(
     (id, opts) => {
       const result = container.taskService.rerankTask(
         {
           taskId: id,
           afterId: opts.after,
           beforeId: opts.before,
-          position: opts.position ? parseInt(opts.position, 10) : void 0
+          position: opts.position ? parseInt(opts.position, 10) : void 0,
+          top: opts.top,
+          bottom: opts.bottom
         },
         opts.project
       );
@@ -2139,6 +2393,8 @@ function buildCLI(container) {
   registerProjectUpdate(project, container);
   registerProjectDelete(project, container);
   registerProjectSetDefault(project, container);
+  registerProjectLink(project, container);
+  registerProjectUnlink(project, container);
   const task = program.command("task").description("Manage tasks");
   registerTaskCreate(task, container);
   registerTaskList(task, container);
@@ -2156,7 +2412,7 @@ function buildCLI(container) {
   registerDepList(dep, container);
   registerDepGraph(dep, container);
   program.command("tui").description("Launch interactive terminal UI").option("-p, --project <project>", "Start with specific project").action(async (opts) => {
-    const { launchTUI } = await import("./tui-5JJH67YY.js");
+    const { launchTUI } = await import("./tui-4GNIGMCK.js");
     await launchTUI(container, opts.project);
   });
   return program;
@@ -2172,7 +2428,7 @@ async function main() {
   const container = createContainer(db, config.dbPath);
   const args = process.argv.slice(2);
   if (args.length === 0) {
-    const { launchTUI } = await import("./tui-5JJH67YY.js");
+    const { launchTUI } = await import("./tui-4GNIGMCK.js");
     await launchTUI(container);
   } else {
     const program = buildCLI(container);