askcli: resolve aliases for selector task 0b9480fe-ec1b-4c0e-a8b0-88f1f08b56d3

11 files changed, 606 insertions, 85 deletions

diff --git a/internal/askcli/command_delete.go b/internal/askcli/command_delete.go
index 45f0f3d..64bcdfc 100644
--- a/internal/askcli/command_delete.go
+++ b/internal/askcli/command_delete.go
@@ -11,16 +11,16 @@ func (d Dispatcher) handleDelete(ctx context.Context, args []string, stdin io.Re
 		io.WriteString(stderr, "error: ask delete requires a UUID argument\n")
 		return 1, nil
 	}
-	uuid := NormalizeUUID(args[1])
-	if IsNumericID(uuid) {
-		io.WriteString(stderr, RejectNumericID())
-		return 1, nil
+	resolved, _, code, err := d.resolveTaskSelector(ctx, args[1], stderr)
+	if err != nil {
+		writeInfoError(stderr, err)
+		return code, nil
 	}
 	var outBuf bytes.Buffer
-	code, err := d.runner.Run(ctx, []string{"uuid:" + uuid, "delete"}, stdin, &outBuf, io.Discard)
+	code, err = d.runner.Run(ctx, []string{"uuid:" + resolved.UUID, "delete"}, stdin, &outBuf, io.Discard)
 	if code != 0 {
 		return code, err
 	}
-	io.WriteString(stdout, FormatSuccess(uuid))
+	io.WriteString(stdout, FormatSuccess(resolved.UUID))
 	return 0, nil
 }
diff --git a/internal/askcli/command_delete_test.go b/internal/askcli/command_delete_test.go
index 9cd2e94..ff3f435 100644
--- a/internal/askcli/command_delete_test.go
+++ b/internal/askcli/command_delete_test.go
@@ -4,12 +4,18 @@ import (
 	"bytes"
 	"context"
 	"io"
+	"path/filepath"
 	"strings"
 	"testing"
+	"time"
 )
 
 func TestHandleDelete_Success(t *testing.T) {
 	d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+		if len(args) == 2 && args[0] == "uuid:test-uuid-123" && args[1] == "export" {
+			io.WriteString(stdout, `[{"uuid":"test-uuid-123","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+			return 0, nil
+		}
 		return 0, nil
 	}})
 	var stdout, stderr bytes.Buffer
@@ -81,6 +87,10 @@ func TestHandleDelete_CommandFails(t *testing.T) {
 func TestHandleDelete_PassesCorrectArgs(t *testing.T) {
 	var capturedArgs []string
 	d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+		if len(args) == 2 && args[1] == "export" {
+			io.WriteString(stdout, `[{"uuid":"my-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+			return 0, nil
+		}
 		capturedArgs = args
 		return 0, nil
 	}})
@@ -90,3 +100,41 @@ func TestHandleDelete_PassesCorrectArgs(t *testing.T) {
 		t.Fatalf("capturedArgs = %v, want [uuid:my-uuid, delete]", capturedArgs)
 	}
 }
+
+func TestHandleDelete_AliasSelector(t *testing.T) {
+	dir := t.TempDir()
+	oldRoot := taskAliasCacheRoot
+	oldNow := nowTaskAliasCache
+	taskAliasCacheRoot = func() (string, error) { return filepath.Join(dir, "hexai"), nil }
+	nowTaskAliasCache = func() time.Time { return time.Date(2026, 3, 26, 12, 0, 0, 0, time.UTC) }
+	defer func() {
+		taskAliasCacheRoot = oldRoot
+		nowTaskAliasCache = oldNow
+	}()
+
+	writeTaskAliasCacheForTest(t, taskAliasCache{
+		NextID: 1,
+		Entries: []taskAliasCacheEntry{
+			{UUID: "test-uuid-123", Alias: "0", CreatedAt: nowTaskAliasCache()},
+		},
+	})
+
+	var capturedArgs []string
+	d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+		if len(args) == 2 && args[0] == "uuid:test-uuid-123" && args[1] == "export" {
+			io.WriteString(stdout, `[{"uuid":"test-uuid-123","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+			return 0, nil
+		}
+		capturedArgs = args
+		return 0, nil
+	}})
+
+	var stdout, stderr bytes.Buffer
+	code, _ := d.Dispatch(context.Background(), []string{"delete", "0"}, &bytes.Buffer{}, &stdout, &stderr)
+	if code != 0 {
+		t.Fatalf("delete code = %d stderr = %q", code, stderr.String())
+	}
+	if len(capturedArgs) != 2 || capturedArgs[0] != "uuid:test-uuid-123" || capturedArgs[1] != "delete" {
+		t.Fatalf("capturedArgs = %v, want [uuid:test-uuid-123 delete]", capturedArgs)
+	}
+}
diff --git a/internal/askcli/command_dep.go b/internal/askcli/command_dep.go
index a399c84..403afee 100644
--- a/internal/askcli/command_dep.go
+++ b/internal/askcli/command_dep.go
@@ -30,30 +30,30 @@ func (d Dispatcher) handleDepAddRm(ctx context.Context, args []string, stdout, s
 		io.WriteString(stderr, "error: ask dep add/rm requires <uuid> <dep-uuid>\n")
 		return 1, nil
 	}
-	uuid := NormalizeUUID(args[2])
-	if IsNumericID(uuid) {
-		io.WriteString(stderr, RejectNumericID())
-		return 1, nil
+	resolved, _, code, err := d.resolveTaskSelector(ctx, args[2], stderr)
+	if err != nil {
+		writeInfoError(stderr, err)
+		return code, nil
 	}
-	depUUID := NormalizeUUID(args[3])
-	if IsNumericID(depUUID) {
-		io.WriteString(stderr, RejectNumericID())
-		return 1, nil
+	dependency, _, code, err := d.resolveTaskSelector(ctx, args[3], stderr)
+	if err != nil {
+		writeInfoError(stderr, err)
+		return code, nil
 	}
 	op := args[1]
 	var modArg string
 	if op == "add" {
-		modArg = "depends:" + depUUID
+		modArg = "depends:" + dependency.UUID
 	} else {
-		modArg = "depends:-" + depUUID
+		modArg = "depends:-" + dependency.UUID
 	}
 	var outBuf bytes.Buffer
 	// uuid:<uuid> scopes the modify to exactly one task; modArg sets the dependency.
-	code, err := d.runner.Run(ctx, []string{"uuid:" + uuid, "modify", modArg}, nil, &outBuf, io.Discard)
+	code, err = d.runner.Run(ctx, []string{"uuid:" + resolved.UUID, "modify", modArg}, nil, &outBuf, io.Discard)
 	if code != 0 {
 		return code, err
 	}
-	io.WriteString(stdout, FormatSuccess(uuid))
+	io.WriteString(stdout, FormatSuccess(resolved.UUID))
 	return 0, nil
 }
 
@@ -62,20 +62,10 @@ func (d Dispatcher) handleDepList(ctx context.Context, args []string, stdout, st
 		io.WriteString(stderr, "error: ask dep list requires <uuid>\n")
 		return 1, nil
 	}
-	uuid := NormalizeUUID(args[2])
-	if IsNumericID(uuid) {
-		io.WriteString(stderr, RejectNumericID())
-		return 1, nil
-	}
-	var outBuf bytes.Buffer
-	code, err := d.runner.Run(ctx, []string{"uuid:" + uuid, "export"}, nil, &outBuf, stderr)
-	if code != 0 {
-		return code, err
-	}
-	tasks, err := ParseTaskExport(&outBuf)
+	_, tasks, code, err := d.resolveTaskSelector(ctx, args[2], stderr)
 	if err != nil {
-		fmt.Fprintf(stderr, "error: failed to parse task data: %v\n", err)
-		return 1, nil
+		writeInfoError(stderr, err)
+		return code, nil
 	}
 	if len(tasks) == 0 {
 		io.WriteString(stdout, "no dependencies\n")
diff --git a/internal/askcli/command_dep_test.go b/internal/askcli/command_dep_test.go
index 6139afa..8045df3 100644
--- a/internal/askcli/command_dep_test.go
+++ b/internal/askcli/command_dep_test.go
@@ -4,13 +4,24 @@ import (
 	"bytes"
 	"context"
 	"io"
+	"path/filepath"
 	"strings"
 	"testing"
+	"time"
 )
 
 func TestHandleDep_AddSuccess(t *testing.T) {
 	var capturedArgs []string
 	d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+		if len(args) == 2 && args[1] == "export" {
+			switch args[0] {
+			case "uuid:uuid-1":
+				io.WriteString(stdout, `[{"uuid":"uuid-1","description":"Task","status":"pending","priority":"M","tags":[],"urgency":10,"depends":[]}]`)
+			case "uuid:uuid-2":
+				io.WriteString(stdout, `[{"uuid":"uuid-2","description":"Task","status":"pending","priority":"M","tags":[],"urgency":10,"depends":[]}]`)
+			}
+			return 0, nil
+		}
 		capturedArgs = args
 		return 0, nil
 	}})
@@ -30,6 +41,15 @@ func TestHandleDep_AddSuccess(t *testing.T) {
 
 func TestHandleDep_RmSuccess(t *testing.T) {
 	d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+		if len(args) == 2 && args[1] == "export" {
+			switch args[0] {
+			case "uuid:uuid-1":
+				io.WriteString(stdout, `[{"uuid":"uuid-1","description":"Task","status":"pending","priority":"M","tags":[],"urgency":10,"depends":[]}]`)
+			case "uuid:uuid-2":
+				io.WriteString(stdout, `[{"uuid":"uuid-2","description":"Task","status":"pending","priority":"M","tags":[],"urgency":10,"depends":[]}]`)
+			}
+			return 0, nil
+		}
 		return 0, nil
 	}})
 	var stdout, stderr bytes.Buffer
@@ -84,8 +104,12 @@ func TestHandleDep_AcceptUUIDPrefix(t *testing.T) {
 			var capturedArgs []string
 			export := `[{"uuid":"uuid-1","description":"T","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`
 			d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+				if len(args) == 2 && args[1] == "export" {
+					capturedArgs = args
+					io.WriteString(stdout, export)
+					return 0, nil
+				}
 				capturedArgs = args
-				io.WriteString(stdout, export)
 				return 0, nil
 			}})
 			var stdout, stderr bytes.Buffer
@@ -100,6 +124,50 @@ func TestHandleDep_AcceptUUIDPrefix(t *testing.T) {
 	}
 }
 
+func TestHandleDep_AliasSelectors(t *testing.T) {
+	dir := t.TempDir()
+	oldRoot := taskAliasCacheRoot
+	oldNow := nowTaskAliasCache
+	taskAliasCacheRoot = func() (string, error) { return filepath.Join(dir, "hexai"), nil }
+	nowTaskAliasCache = func() time.Time { return time.Date(2026, 3, 26, 12, 0, 0, 0, time.UTC) }
+	defer func() {
+		taskAliasCacheRoot = oldRoot
+		nowTaskAliasCache = oldNow
+	}()
+
+	writeTaskAliasCacheForTest(t, taskAliasCache{
+		NextID: 2,
+		Entries: []taskAliasCacheEntry{
+			{UUID: "uuid-1", Alias: "0", CreatedAt: nowTaskAliasCache()},
+			{UUID: "uuid-2", Alias: "1", CreatedAt: nowTaskAliasCache()},
+		},
+	})
+
+	var capturedArgs []string
+	d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+		if len(args) == 2 && args[1] == "export" {
+			switch args[0] {
+			case "uuid:uuid-1":
+				io.WriteString(stdout, `[{"uuid":"uuid-1","description":"T1","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+			case "uuid:uuid-2":
+				io.WriteString(stdout, `[{"uuid":"uuid-2","description":"T2","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+			}
+			return 0, nil
+		}
+		capturedArgs = args
+		return 0, nil
+	}})
+
+	var stdout, stderr bytes.Buffer
+	code, _ := d.Dispatch(context.Background(), []string{"dep", "add", "0", "1"}, nil, &stdout, &stderr)
+	if code != 0 {
+		t.Fatalf("dep add code = %d stderr = %q", code, stderr.String())
+	}
+	if len(capturedArgs) < 3 || capturedArgs[0] != "uuid:uuid-1" || capturedArgs[2] != "depends:uuid-2" {
+		t.Fatalf("capturedArgs = %v, want resolved alias UUIDs", capturedArgs)
+	}
+}
+
 func TestHandleDep_NumericUUID(t *testing.T) {
 	d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
 		return 0, nil
diff --git a/internal/askcli/command_info_add.go b/internal/askcli/command_info_add.go
index 9a7b518..030cf62 100644
--- a/internal/askcli/command_info_add.go
+++ b/internal/askcli/command_info_add.go
@@ -31,11 +31,8 @@ func (d Dispatcher) handleInfo(ctx context.Context, args []string, stdout, stder
 
 func (d Dispatcher) infoTasks(ctx context.Context, args []string, stderr io.Writer) ([]TaskExport, int, error) {
 	if len(args) >= 2 {
-		uuid := NormalizeUUID(args[1])
-		if IsNumericID(uuid) {
-			return nil, 1, fmt.Errorf(strings.TrimSpace(RejectNumericID()))
-		}
-		return d.exportTasks(ctx, []string{"uuid:" + uuid, "export"}, stderr)
+		_, tasks, code, err := d.resolveTaskSelector(ctx, args[1], stderr)
+		return tasks, code, err
 	}
 	return d.startedInfoTasks(ctx, stderr)
 }
diff --git a/internal/askcli/command_info_add_test.go b/internal/askcli/command_info_add_test.go
index 9bc13df..46996f7 100644
--- a/internal/askcli/command_info_add_test.go
+++ b/internal/askcli/command_info_add_test.go
@@ -4,8 +4,10 @@ import (
 	"bytes"
 	"context"
 	"io"
+	"path/filepath"
 	"strings"
 	"testing"
+	"time"
 )
 
 func TestHandleInfo_Success(t *testing.T) {
@@ -34,6 +36,42 @@ func TestHandleInfo_Success(t *testing.T) {
 	}
 }
 
+func TestHandleInfo_AliasSelector(t *testing.T) {
+	dir := t.TempDir()
+	oldRoot := taskAliasCacheRoot
+	oldNow := nowTaskAliasCache
+	taskAliasCacheRoot = func() (string, error) { return filepath.Join(dir, "hexai"), nil }
+	nowTaskAliasCache = func() time.Time { return time.Date(2026, 3, 26, 12, 0, 0, 0, time.UTC) }
+	defer func() {
+		taskAliasCacheRoot = oldRoot
+		nowTaskAliasCache = oldNow
+	}()
+
+	writeTaskAliasCacheForTest(t, taskAliasCache{
+		NextID: 1,
+		Entries: []taskAliasCacheEntry{
+			{UUID: "test-uuid", Alias: "0", CreatedAt: nowTaskAliasCache()},
+		},
+	})
+
+	jsonData := `[{"uuid":"test-uuid","description":"Test task","status":"pending","priority":"H","tags":["cli"],"urgency":15.0,"depends":[]}]`
+	d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+		if len(args) > 0 && strings.HasPrefix(args[0], "uuid:test-uuid") {
+			io.WriteString(stdout, jsonData)
+		}
+		return 0, nil
+	}})
+
+	var stdout, stderr bytes.Buffer
+	code, _ := d.Dispatch(context.Background(), []string{"info", "0"}, nil, &stdout, &stderr)
+	if code != 0 {
+		t.Fatalf("info code = %d, want 0", code)
+	}
+	if !strings.Contains(stdout.String(), "test-uuid") {
+		t.Fatalf("stdout = %q, want resolved UUID", stdout.String())
+	}
+}
+
 func TestHandleInfo_NumericID(t *testing.T) {
 	d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
 		return 0, nil
diff --git a/internal/askcli/command_write.go b/internal/askcli/command_write.go
index 64000d7..afa1475 100644
--- a/internal/askcli/command_write.go
+++ b/internal/askcli/command_write.go
@@ -12,18 +12,18 @@ func (d Dispatcher) handleDenotate(ctx context.Context, args []string, stdout, s
 		io.WriteString(stderr, "error: ask denotate requires a UUID and text argument\n")
 		return 1, nil
 	}
-	uuid := NormalizeUUID(args[1])
-	if IsNumericID(uuid) {
-		io.WriteString(stderr, RejectNumericID())
-		return 1, nil
+	resolved, _, code, err := d.resolveTaskSelector(ctx, args[1], stderr)
+	if err != nil {
+		writeInfoError(stderr, err)
+		return code, nil
 	}
 	text := args[2]
 	var outBuf bytes.Buffer
-	code, err := d.runner.Run(ctx, []string{"uuid:" + uuid, "denotate", text}, nil, &outBuf, io.Discard)
+	code, err = d.runner.Run(ctx, []string{"uuid:" + resolved.UUID, "denotate", text}, nil, &outBuf, io.Discard)
 	if code != 0 {
 		return code, err
 	}
-	io.WriteString(stdout, FormatSuccess(uuid))
+	io.WriteString(stdout, FormatSuccess(resolved.UUID))
 	return 0, nil
 }
 
@@ -32,18 +32,18 @@ func (d Dispatcher) handleModify(ctx context.Context, args []string, stdout, std
 		io.WriteString(stderr, "error: ask modify requires a UUID and modification args\n")
 		return 1, nil
 	}
-	uuid := NormalizeUUID(args[1])
-	if IsNumericID(uuid) {
-		io.WriteString(stderr, RejectNumericID())
-		return 1, nil
+	resolved, _, code, err := d.resolveTaskSelector(ctx, args[1], stderr)
+	if err != nil {
+		writeInfoError(stderr, err)
+		return code, nil
 	}
 	modArgs := args[2:]
 	var outBuf bytes.Buffer
-	code, err := d.runner.Run(ctx, append([]string{"uuid:" + uuid, "modify"}, modArgs...), nil, &outBuf, io.Discard)
+	code, err = d.runner.Run(ctx, append([]string{"uuid:" + resolved.UUID, "modify"}, modArgs...), nil, &outBuf, io.Discard)
 	if code != 0 {
 		return code, err
 	}
-	io.WriteString(stdout, FormatSuccess(uuid))
+	io.WriteString(stdout, FormatSuccess(resolved.UUID))
 	return 0, nil
 }
 
@@ -52,18 +52,18 @@ func (d Dispatcher) handleAnnotate(ctx context.Context, args []string, stdout, s
 		io.WriteString(stderr, "error: ask annotate requires a UUID and note argument\n")
 		return 1, nil
 	}
-	uuid := NormalizeUUID(args[1])
-	if IsNumericID(uuid) {
-		io.WriteString(stderr, RejectNumericID())
-		return 1, nil
+	resolved, _, code, err := d.resolveTaskSelector(ctx, args[1], stderr)
+	if err != nil {
+		writeInfoError(stderr, err)
+		return code, nil
 	}
 	note := strings.Join(args[2:], " ")
 	var outBuf bytes.Buffer
-	code, err := d.runner.Run(ctx, []string{"uuid:" + uuid, "annotate", note}, nil, &outBuf, io.Discard)
+	code, err = d.runner.Run(ctx, []string{"uuid:" + resolved.UUID, "annotate", note}, nil, &outBuf, io.Discard)
 	if code != 0 {
 		return code, err
 	}
-	io.WriteString(stdout, FormatSuccess(uuid))
+	io.WriteString(stdout, FormatSuccess(resolved.UUID))
 	return 0, nil
 }
 
@@ -72,19 +72,19 @@ func (d Dispatcher) handleStart(ctx context.Context, args []string, stdout, stde
 		io.WriteString(stderr, "error: ask start requires a UUID argument\n")
 		return 1, nil
 	}
-	uuid := NormalizeUUID(args[1])
-	if IsNumericID(uuid) {
-		io.WriteString(stderr, RejectNumericID())
-		return 1, nil
+	resolved, _, code, err := d.resolveTaskSelector(ctx, args[1], stderr)
+	if err != nil {
+		writeInfoError(stderr, err)
+		return code, nil
 	}
 	var outBuf bytes.Buffer
 	// uuid:<uuid> is used as the filter so taskwarrior selects the exact task;
 	// the action verb follows the filter.
-	code, err := d.runner.Run(ctx, []string{"uuid:" + uuid, "start"}, nil, &outBuf, io.Discard)
+	code, err = d.runner.Run(ctx, []string{"uuid:" + resolved.UUID, "start"}, nil, &outBuf, io.Discard)
 	if code != 0 {
 		return code, err
 	}
-	io.WriteString(stdout, FormatSuccess(uuid))
+	io.WriteString(stdout, FormatSuccess(resolved.UUID))
 	return 0, nil
 }
 
@@ -93,17 +93,17 @@ func (d Dispatcher) handleStop(ctx context.Context, args []string, stdout, stder
 		io.WriteString(stderr, "error: ask stop requires a UUID argument\n")
 		return 1, nil
 	}
-	uuid := NormalizeUUID(args[1])
-	if IsNumericID(uuid) {
-		io.WriteString(stderr, RejectNumericID())
-		return 1, nil
+	resolved, _, code, err := d.resolveTaskSelector(ctx, args[1], stderr)
+	if err != nil {
+		writeInfoError(stderr, err)
+		return code, nil
 	}
 	var outBuf bytes.Buffer
-	code, err := d.runner.Run(ctx, []string{"uuid:" + uuid, "stop"}, nil, &outBuf, io.Discard)
+	code, err = d.runner.Run(ctx, []string{"uuid:" + resolved.UUID, "stop"}, nil, &outBuf, io.Discard)
 	if code != 0 {
 		return code, err
 	}
-	io.WriteString(stdout, FormatSuccess(uuid))
+	io.WriteString(stdout, FormatSuccess(resolved.UUID))
 	return 0, nil
 }
 
@@ -112,17 +112,17 @@ func (d Dispatcher) handleDone(ctx context.Context, args []string, stdout, stder
 		io.WriteString(stderr, "error: ask done requires a UUID argument\n")
 		return 1, nil
 	}
-	uuid := NormalizeUUID(args[1])
-	if IsNumericID(uuid) {
-		io.WriteString(stderr, RejectNumericID())
-		return 1, nil
+	resolved, _, code, err := d.resolveTaskSelector(ctx, args[1], stderr)
+	if err != nil {
+		writeInfoError(stderr, err)
+		return code, nil
 	}
 	var outBuf bytes.Buffer
-	code, err := d.runner.Run(ctx, []string{"uuid:" + uuid, "done"}, nil, &outBuf, io.Discard)
+	code, err = d.runner.Run(ctx, []string{"uuid:" + resolved.UUID, "done"}, nil, &outBuf, io.Discard)
 	if code != 0 {
 		return code, err
 	}
-	io.WriteString(stdout, FormatSuccess(uuid))
+	io.WriteString(stdout, FormatSuccess(resolved.UUID))
 	return 0, nil
 }
 
@@ -131,18 +131,18 @@ func (d Dispatcher) handlePriority(ctx context.Context, args []string, stdout, s
 		io.WriteString(stderr, "error: ask priority requires a UUID and priority (H/M/L)\n")
 		return 1, nil
 	}
-	uuid := NormalizeUUID(args[1])
-	if IsNumericID(uuid) {
-		io.WriteString(stderr, RejectNumericID())
-		return 1, nil
+	resolved, _, code, err := d.resolveTaskSelector(ctx, args[1], stderr)
+	if err != nil {
+		writeInfoError(stderr, err)
+		return code, nil
 	}
 	priority := args[2]
 	var outBuf bytes.Buffer
-	code, err := d.runner.Run(ctx, []string{"uuid:" + uuid, "modify", "priority:" + priority}, nil, &outBuf, io.Discard)
+	code, err = d.runner.Run(ctx, []string{"uuid:" + resolved.UUID, "modify", "priority:" + priority}, nil, &outBuf, io.Discard)
 	if code != 0 {
 		return code, err
 	}
-	io.WriteString(stdout, FormatSuccess(uuid))
+	io.WriteString(stdout, FormatSuccess(resolved.UUID))
 	return 0, nil
 }
 
@@ -151,17 +151,17 @@ func (d Dispatcher) handleTag(ctx context.Context, args []string, stdout, stderr
 		io.WriteString(stderr, "error: ask tag requires a UUID and +/-tag\n")
 		return 1, nil
 	}
-	uuid := NormalizeUUID(args[1])
-	if IsNumericID(uuid) {
-		io.WriteString(stderr, RejectNumericID())
-		return 1, nil
+	resolved, _, code, err := d.resolveTaskSelector(ctx, args[1], stderr)
+	if err != nil {
+		writeInfoError(stderr, err)
+		return code, nil
 	}
 	tag := args[2]
 	var outBuf bytes.Buffer
-	code, err := d.runner.Run(ctx, []string{"uuid:" + uuid, "modify", tag}, nil, &outBuf, io.Discard)
+	code, err = d.runner.Run(ctx, []string{"uuid:" + resolved.UUID, "modify", tag}, nil, &outBuf, io.Discard)
 	if code != 0 {
 		return code, err
 	}
-	io.WriteString(stdout, FormatSuccess(uuid))
+	io.WriteString(stdout, FormatSuccess(resolved.UUID))
 	return 0, nil
 }
diff --git a/internal/askcli/command_write_test.go b/internal/askcli/command_write_test.go
index 0b6cfb5..2ed5fc9 100644
--- a/internal/askcli/command_write_test.go
+++ b/internal/askcli/command_write_test.go
@@ -4,12 +4,56 @@ import (
 	"bytes"
 	"context"
 	"io"
+	"path/filepath"
 	"strings"
 	"testing"
+	"time"
 )
 
+func TestHandleStart_AliasSelector(t *testing.T) {
+	dir := t.TempDir()
+	oldRoot := taskAliasCacheRoot
+	oldNow := nowTaskAliasCache
+	taskAliasCacheRoot = func() (string, error) { return filepath.Join(dir, "hexai"), nil }
+	nowTaskAliasCache = func() time.Time { return time.Date(2026, 3, 26, 12, 0, 0, 0, time.UTC) }
+	defer func() {
+		taskAliasCacheRoot = oldRoot
+		nowTaskAliasCache = oldNow
+	}()
+
+	writeTaskAliasCacheForTest(t, taskAliasCache{
+		NextID: 1,
+		Entries: []taskAliasCacheEntry{
+			{UUID: "test-uuid", Alias: "0", CreatedAt: nowTaskAliasCache()},
+		},
+	})
+
+	var capturedArgs []string
+	d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+		if len(args) == 2 && args[0] == "uuid:test-uuid" && args[1] == "export" {
+			io.WriteString(stdout, `[{"uuid":"test-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+			return 0, nil
+		}
+		capturedArgs = args
+		return 0, nil
+	}})
+
+	var stdout, stderr bytes.Buffer
+	code, _ := d.Dispatch(context.Background(), []string{"start", "0"}, &bytes.Buffer{}, &stdout, &stderr)
+	if code != 0 {
+		t.Fatalf("start code = %d stderr = %q", code, stderr.String())
+	}
+	if len(capturedArgs) != 2 || capturedArgs[0] != "uuid:test-uuid" || capturedArgs[1] != "start" {
+		t.Fatalf("capturedArgs = %v, want [uuid:test-uuid start]", capturedArgs)
+	}
+}
+
 func TestHandleDenotate_Success(t *testing.T) {
 	d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+		if len(args) == 2 && args[0] == "uuid:test-uuid" && args[1] == "export" {
+			io.WriteString(stdout, `[{"uuid":"test-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+			return 0, nil
+		}
 		return 0, nil
 	}})
 	var stdout, stderr bytes.Buffer
@@ -51,6 +95,10 @@ func TestHandleDenotate_MissingArgs(t *testing.T) {
 
 func TestHandleModify_Success(t *testing.T) {
 	d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+		if len(args) == 2 && args[0] == "uuid:test-uuid" && args[1] == "export" {
+			io.WriteString(stdout, `[{"uuid":"test-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+			return 0, nil
+		}
 		return 0, nil
 	}})
 	var stdout, stderr bytes.Buffer
@@ -77,6 +125,10 @@ func TestHandleModify_NumericID(t *testing.T) {
 
 func TestHandleAnnotate_Success(t *testing.T) {
 	d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+		if len(args) == 2 && args[0] == "uuid:test-uuid" && args[1] == "export" {
+			io.WriteString(stdout, `[{"uuid":"test-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+			return 0, nil
+		}
 		return 0, nil
 	}})
 	var stdout, stderr bytes.Buffer
@@ -103,6 +155,10 @@ func TestHandleAnnotate_MissingArgs(t *testing.T) {
 
 func TestHandleStart_Success(t *testing.T) {
 	d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+		if len(args) == 2 && args[0] == "uuid:test-uuid" && args[1] == "export" {
+			io.WriteString(stdout, `[{"uuid":"test-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+			return 0, nil
+		}
 		return 0, nil
 	}})
 	var stdout, stderr bytes.Buffer
@@ -129,6 +185,10 @@ func TestHandleStart_MissingUUID(t *testing.T) {
 
 func TestHandleStop_Success(t *testing.T) {
 	d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+		if len(args) == 2 && args[0] == "uuid:test-uuid" && args[1] == "export" {
+			io.WriteString(stdout, `[{"uuid":"test-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+			return 0, nil
+		}
 		return 0, nil
 	}})
 	var stdout, stderr bytes.Buffer
@@ -140,6 +200,10 @@ func TestHandleStop_Success(t *testing.T) {
 
 func TestHandleDone_Success(t *testing.T) {
 	d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+		if len(args) == 2 && args[0] == "uuid:test-uuid" && args[1] == "export" {
+			io.WriteString(stdout, `[{"uuid":"test-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+			return 0, nil
+		}
 		return 0, nil
 	}})
 	var stdout, stderr bytes.Buffer
@@ -151,6 +215,10 @@ func TestHandleDone_Success(t *testing.T) {
 
 func TestHandlePriority_Success(t *testing.T) {
 	d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+		if len(args) == 2 && args[0] == "uuid:test-uuid" && args[1] == "export" {
+			io.WriteString(stdout, `[{"uuid":"test-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+			return 0, nil
+		}
 		return 0, nil
 	}})
 	var stdout, stderr bytes.Buffer
@@ -174,6 +242,10 @@ func TestHandlePriority_MissingArgs(t *testing.T) {
 
 func TestHandleTag_Success(t *testing.T) {
 	d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+		if len(args) == 2 && args[0] == "uuid:test-uuid" && args[1] == "export" {
+			io.WriteString(stdout, `[{"uuid":"test-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+			return 0, nil
+		}
 		return 0, nil
 	}})
 	var stdout, stderr bytes.Buffer
@@ -217,6 +289,10 @@ func TestAllWriteHandlers_PassCorrectArgs(t *testing.T) {
 		t.Run(tc.subcommand, func(t *testing.T) {
 			var capturedArgs []string
 			d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+				if len(args) == 2 && args[1] == "export" {
+					io.WriteString(stdout, `[{"uuid":"my-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+					return 0, nil
+				}
 				capturedArgs = args
 				return 0, nil
 			}})
@@ -257,6 +333,10 @@ func TestAllWriteHandlers_AcceptUUIDPrefix(t *testing.T) {
 		t.Run(tc.subcommand, func(t *testing.T) {
 			var capturedArgs []string
 			d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+				if len(args) == 2 && args[1] == "export" {
+					io.WriteString(stdout, `[{"uuid":"my-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+					return 0, nil
+				}
 				capturedArgs = args
 				return 0, nil
 			}})
diff --git a/internal/askcli/task_alias_cache.go b/internal/askcli/task_alias_cache.go
index a914e6b..c6a0ba2 100644
--- a/internal/askcli/task_alias_cache.go
+++ b/internal/askcli/task_alias_cache.go
@@ -168,6 +168,30 @@ func (c *taskAliasCache) ensureAlias(uuid string, now time.Time) (string, bool)
 	return alias, true
 }
 
+func (c *taskAliasCache) lookupUUIDByAlias(alias string, now time.Time) (string, bool, bool) {
+	for i := range c.Entries {
+		if c.Entries[i].Alias != alias {
+			continue
+		}
+		changed := !c.Entries[i].LastAccessedAt.Equal(now)
+		c.Entries[i].LastAccessedAt = now
+		return c.Entries[i].UUID, true, changed
+	}
+	return "", false, false
+}
+
+func (c *taskAliasCache) lookupAliasByUUID(uuid string, now time.Time) (string, bool, bool) {
+	for i := range c.Entries {
+		if c.Entries[i].UUID != uuid {
+			continue
+		}
+		changed := !c.Entries[i].LastAccessedAt.Equal(now)
+		c.Entries[i].LastAccessedAt = now
+		return c.Entries[i].Alias, true, changed
+	}
+	return "", false, false
+}
+
 func (c taskAliasCache) save(path string) error {
 	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
 		return fmt.Errorf("create task alias cache dir: %w", err)
diff --git a/internal/askcli/task_selector.go b/internal/askcli/task_selector.go
new file mode 100644
index 0000000..7702153
--- /dev/null
+++ b/internal/askcli/task_selector.go
@@ -0,0 +1,119 @@
+package askcli
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"strings"
+)
+
+type resolvedTaskSelector struct {
+	Input     string
+	UUID      string
+	Alias     string
+	UsedAlias bool
+}
+
+func (d Dispatcher) resolveTaskSelector(ctx context.Context, selector string, stderr io.Writer) (resolvedTaskSelector, []TaskExport, int, error) {
+	normalized, requiresLookup, err := normalizeTaskSelectorInput(selector)
+	if err != nil {
+		return resolvedTaskSelector{}, nil, 1, err
+	}
+
+	resolved, err := resolveTaskSelectorFromCache(normalized, requiresLookup)
+	if err != nil {
+		return resolvedTaskSelector{}, nil, 1, err
+	}
+
+	tasks, code, err := d.exportTasks(ctx, []string{"uuid:" + resolved.UUID, "export"}, stderr)
+	if err != nil {
+		if resolved.UsedAlias && strings.Contains(err.Error(), "task not found") {
+			return resolvedTaskSelector{}, nil, 1, fmt.Errorf("alias %q is stale: task %s was not found", selector, resolved.UUID)
+		}
+		return resolvedTaskSelector{}, nil, code, err
+	}
+
+	aliases, err := ensureTaskAliases(tasks)
+	if err != nil {
+		return resolvedTaskSelector{}, nil, 1, err
+	}
+	if alias, ok := aliases[resolved.UUID]; ok {
+		resolved.Alias = alias
+	}
+	return resolved, tasks, 0, nil
+}
+
+func normalizeTaskSelectorInput(selector string) (string, bool, error) {
+	normalized := NormalizeUUID(selector)
+	if selector != normalized && IsNumericID(normalized) {
+		return "", false, fmt.Errorf(strings.TrimSpace(RejectNumericID()))
+	}
+	return normalized, selector == normalized, nil
+}
+
+func resolveTaskSelectorFromCache(selector string, allowAlias bool) (resolvedTaskSelector, error) {
+	resolved := resolvedTaskSelector{Input: selector, UUID: selector}
+	if !allowAlias || !looksLikeTaskAlias(selector) {
+		return resolved, nil
+	}
+
+	cache, path, err := loadTaskAliasCache()
+	if err != nil {
+		return resolvedTaskSelector{}, err
+	}
+
+	now := nowTaskAliasCache().UTC()
+	changed := cache.prune(now)
+	uuidFromAlias, aliasFound, aliasChanged := cache.lookupUUIDByAlias(selector, now)
+	changed = changed || aliasChanged
+	aliasForUUID, uuidFound, uuidChanged := cache.lookupAliasByUUID(selector, now)
+	changed = changed || uuidChanged
+
+	switch {
+	case aliasFound && uuidFound && uuidFromAlias != selector:
+		if changed {
+			if err := cache.save(path); err != nil {
+				return resolvedTaskSelector{}, err
+			}
+		}
+		return resolvedTaskSelector{}, fmt.Errorf("task selector %q is ambiguous: it matches alias for %s and UUID %s; use uuid:%s to force UUID", selector, uuidFromAlias, selector, selector)
+	case aliasFound:
+		if changed {
+			if err := cache.save(path); err != nil {
+				return resolvedTaskSelector{}, err
+			}
+		}
+		return resolvedTaskSelector{
+			Input:     selector,
+			UUID:      uuidFromAlias,
+			Alias:     selector,
+			UsedAlias: true,
+		}, nil
+	case uuidFound:
+		if changed {
+			if err := cache.save(path); err != nil {
+				return resolvedTaskSelector{}, err
+			}
+		}
+		return resolvedTaskSelector{
+			Input: selector,
+			UUID:  selector,
+			Alias: aliasForUUID,
+		}, nil
+	default:
+		if IsNumericID(selector) {
+			return resolvedTaskSelector{}, fmt.Errorf(strings.TrimSpace(RejectNumericID()))
+		}
+		if changed {
+			if err := cache.save(path); err != nil {
+				return resolvedTaskSelector{}, err
+			}
+		}
+		return resolvedTaskSelector{}, fmt.Errorf("task selector %q did not match a known alias; use uuid:%s to force UUID", selector, selector)
+	}
+}
+
+func looksLikeTaskAlias(selector string) bool {
+	_, ok := decodeTaskAliasID(selector)
+	return ok && !strings.Contains(selector, "-")
+}
diff --git a/internal/askcli/task_selector_test.go b/internal/askcli/task_selector_test.go
new file mode 100644
index 0000000..7e60665
--- /dev/null
+++ b/internal/askcli/task_selector_test.go
@@ -0,0 +1,157 @@
+package askcli
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestResolveTaskSelectorFromCache_TouchesAliasEntry(t *testing.T) {
+	dir := t.TempDir()
+	oldNow := nowTaskAliasCache
+	oldRoot := taskAliasCacheRoot
+	nowTaskAliasCache = func() time.Time { return time.Date(2026, 3, 26, 12, 0, 0, 0, time.UTC) }
+	taskAliasCacheRoot = func() (string, error) { return filepath.Join(dir, "hexai"), nil }
+	defer func() {
+		nowTaskAliasCache = oldNow
+		taskAliasCacheRoot = oldRoot
+	}()
+
+	writeTaskAliasCacheForTest(t, taskAliasCache{
+		NextID: 2,
+		Entries: []taskAliasCacheEntry{
+			{
+				UUID:           "task-uuid-1",
+				Alias:          "0",
+				CreatedAt:      time.Date(2026, 3, 20, 12, 0, 0, 0, time.UTC),
+				LastAccessedAt: time.Date(2026, 3, 21, 12, 0, 0, 0, time.UTC),
+			},
+		},
+	})
+
+	resolved, err := resolveTaskSelectorFromCache("0", true)
+	if err != nil {
+		t.Fatalf("resolveTaskSelectorFromCache returned error: %v", err)
+	}
+	if !resolved.UsedAlias || resolved.UUID != "task-uuid-1" {
+		t.Fatalf("resolved = %+v, want alias hit for task-uuid-1", resolved)
+	}
+
+	cache := readTaskAliasCacheSnapshot(t)
+	entry := findTaskAliasEntry(t, cache, "task-uuid-1")
+	if got := entry.LastAccessedAt; !got.Equal(nowTaskAliasCache()) {
+		t.Fatalf("LastAccessedAt = %s, want %s", got, nowTaskAliasCache())
+	}
+}
+
+func TestResolveTaskSelectorFromCache_MissingAlias(t *testing.T) {
+	dir := t.TempDir()
+	oldRoot := taskAliasCacheRoot
+	taskAliasCacheRoot = func() (string, error) { return filepath.Join(dir, "hexai"), nil }
+	defer func() { taskAliasCacheRoot = oldRoot }()
+
+	_, err := resolveTaskSelectorFromCache("a", true)
+	if err == nil {
+		t.Fatal("resolveTaskSelectorFromCache returned nil error, want missing alias failure")
+	}
+	if !strings.Contains(err.Error(), `did not match a known alias`) {
+		t.Fatalf("err = %q, want missing alias message", err)
+	}
+}
+
+func TestResolveTaskSelectorFromCache_AmbiguousSelector(t *testing.T) {
+	dir := t.TempDir()
+	oldRoot := taskAliasCacheRoot
+	oldNow := nowTaskAliasCache
+	taskAliasCacheRoot = func() (string, error) { return filepath.Join(dir, "hexai"), nil }
+	nowTaskAliasCache = func() time.Time { return time.Date(2026, 3, 26, 12, 0, 0, 0, time.UTC) }
+	defer func() {
+		taskAliasCacheRoot = oldRoot
+		nowTaskAliasCache = oldNow
+	}()
+
+	writeTaskAliasCacheForTest(t, taskAliasCache{
+		NextID: 11,
+		Entries: []taskAliasCacheEntry{
+			{UUID: "a", Alias: "1", CreatedAt: nowTaskAliasCache()},
+			{UUID: "task-uuid-2", Alias: "a", CreatedAt: nowTaskAliasCache()},
+		},
+	})
+
+	_, err := resolveTaskSelectorFromCache("a", true)
+	if err == nil {
+		t.Fatal("resolveTaskSelectorFromCache returned nil error, want ambiguity")
+	}
+	if !strings.Contains(err.Error(), "ambiguous") {
+		t.Fatalf("err = %q, want ambiguity message", err)
+	}
+}
+
+func TestHandleInfo_StaleAlias(t *testing.T) {
+	dir := t.TempDir()
+	oldRoot := taskAliasCacheRoot
+	oldNow := nowTaskAliasCache
+	taskAliasCacheRoot = func() (string, error) { return filepath.Join(dir, "hexai"), nil }
+	nowTaskAliasCache = func() time.Time { return time.Date(2026, 3, 26, 12, 0, 0, 0, time.UTC) }
+	defer func() {
+		taskAliasCacheRoot = oldRoot
+		nowTaskAliasCache = oldNow
+	}()
+
+	writeTaskAliasCacheForTest(t, taskAliasCache{
+		NextID: 1,
+		Entries: []taskAliasCacheEntry{
+			{UUID: "task-uuid-1", Alias: "0", CreatedAt: nowTaskAliasCache()},
+		},
+	})
+
+	d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+		if len(args) == 2 && args[0] == "uuid:task-uuid-1" && args[1] == "export" {
+			io.WriteString(stdout, "[]")
+		}
+		return 0, nil
+	}})
+
+	var stdout, stderr bytes.Buffer
+	code, _ := d.Dispatch(context.Background(), []string{"info", "0"}, nil, &stdout, &stderr)
+	if code != 1 {
+		t.Fatalf("info code = %d, want 1 for stale alias", code)
+	}
+	if !strings.Contains(stderr.String(), `alias "0" is stale`) {
+		t.Fatalf("stderr = %q, want stale alias message", stderr.String())
+	}
+}
+
+func writeTaskAliasCacheForTest(t *testing.T, cache taskAliasCache) {
+	t.Helper()
+	path, err := taskAliasCachePath()
+	if err != nil {
+		t.Fatalf("taskAliasCachePath: %v", err)
+	}
+	if err := cache.save(path); err != nil {
+		t.Fatalf("cache.save: %v", err)
+	}
+}
+
+func readTaskAliasCacheSnapshot(t *testing.T) taskAliasCache {
+	t.Helper()
+	path, err := taskAliasCachePath()
+	if err != nil {
+		t.Fatalf("taskAliasCachePath: %v", err)
+	}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("os.ReadFile(%s): %v", path, err)
+	}
+	var cache taskAliasCache
+	if err := json.Unmarshal(data, &cache); err != nil {
+		t.Fatalf("json.Unmarshal: %v", err)
+	}
+	return cache
+}